Mathematica commands summary (cheat sheet) Abbreviations Patterns [DC, Tut]

approx Approximation
Hugo Touchette arg Argument Blank: any expr
char Character Double blank: any seq of expr
National Institute for Theoretical Physics (NITheP), Stellenbosch, South Africa cnt Counter
Last updated: May 18, 2016 cond Condition Triple blank: zero or more args
See last page for Mathematica 8 updates dist Distribution x Any expr named x
elem Element xh Expr named x with head h
Equalities, assignments [DC] eqn Equation
eval Evaluation x Exact matching x
= Assign value expr Expression x+2/.x->2 Output: 4
fct Function
:= Delayed eval Also used for repeated eval img Image
x:patt Named expr matching patt
== Equality patt Pattern f[aˆ b]/.f[x: ˆ ]->p[x] Output: p[aˆ b]
rand Random x :v Optional arg with default val v
=. Clear value Same as Clear str String
=== Boolean test Same as SameQ val Value x h:v Typed arg with optional val v
f[x ]:=f[x]=... Remember computed vals var Variable f[n ] f with any named arg n
f[n ,n ] f with identical args
Rules and replacements [DC, Tut] xˆ n x to any named power n
patt->expr Transformation rule Can be assigned to names x ˆn Any expr to any power
patt:->expr Delayed rule Same as :> a +b Sum of two named exprs
expr/.rule Replacement Same as ReplaceAll {a1 ,a2 } List of two named exprs
1+2 x/.x->3 Output: 7 patt/;cond Pattern with cond Read: patt such that cond
expr/.{rule1,rule2} Multiple replacements (x /;NumberQ[x]&&Im[x]==0) Any real number
expr//.rule Replace until no changes Same as ReplaceRepeated rule/;cond Rule with cond
patt?test Pattern matching boolean test
Applications, functions and maps [DC, Tut] f[x ?NumberQ]:=x+2
f@expr Prefix form f[expr] (patt1|patt2|...) patt1 or patt2 or ...
expr//f Postfix form f[expr] {1,x,xˆ 2,yˆ 3}/.(x|xˆ n )->q Output: {1,q,q,yˆ 3}
x˜f˜y Infix form f[x,y] expr/.rule Replacement in expr with rule
f@@expr Replaces the head of expr by f Same as Apply[f,expr] x+2/.x->2 Output: 4
Plus@@{1,2} Output: 1 + 2 = 3 f[a]+f[b]/.f[x ]->xˆ 2 Output: aˆ 2+bˆ 2
Similar to: f[x]/.f->g Output: g[x] Position[f[a],g[b],f[b],f[x ]] Output: {{1}, {2}}
f/@list Map f on list Same as Map[f,list] {1,x,xˆ 2,xˆ 3}/.xˆ n ->r[n] Output: {1,x,r[2],r[3]}
f/@expr Map f on parts of expr Except[c] Anything except c
Map[f,a+b] Output: f[a]+f[b] Except[c,patt] Pattern patt except c
Function[x,body] Function with arg x Same as pure functions Cases[{1,0,2},Except[0]] Output: {1,2}
Function[x,xˆ 2][n] Output: n2 Cases[{1,x,0},Except[0, Integer]] Output: {1}
Map[Function[x,xˆ 2],a+b] Output: a2 + b2
Function[{vars},...] Many args Type specification Files [DC]
body& Pure (anonymous) function Integer N Esc -dsN- Esc Import["file"] Import file or url
(#ˆ 2&)[5] Output: 25 Real R Esc -dsR- Esc Export["file",expr] Export expr in file
Map[#ˆ 2&,a+b] Output: a2 + b2 Complex C Esc -dsC- Esc ImageResolution->pts Image resolution in pts
(1+g[#])&/@{1,2} Output: {1+g[1],1+g[2]} Rational Z Esc -dsZ- Esc ReadList["file"] Returns list from file
#n nth arg in pure function List List type or head <<File‘ Load content of file
## Seq of all args Symbol Any symbol
String String type of head
Formatting [DC] Shortcuts [DC] Head Type Head
√ MatchQ[xˆ 2, Power]
FullForm Display full head form Ctrl -@ ·
MatrixForm Display in matrix form Ctrl -/ Fraction
Column Display in column form Ctrl -ˆ Superscript
TableForm Display in tabular form Ctrl - Subscript
TreeForm Display in tree structure Ctrl - Enter New row
Ctrl -, New column
Lists [DC, Tut]
{i,imax} Simple counter from 1 to imax
{i,imin,imax,di} Counter with step di
Table[expr,cnt] Generate list
list[[i]] ith elem (list or expr)
list[[i,j]] (i, j) elem
list[[i;;j]] Range i to j
Drop[list,n] First n elems dropped
Drop[list,{n}] nth elem dropped
Extract[expr,list] Extract in expr at pos list
Array[f,n] {f (1), f (2), . . . , f (n)}
Array[1+#ˆ 2&,2]
Range[n] {1, 2, 3, . . . , n}
Range[nmin,nmax,dn] Full syntax
Position[expr,patt] List matching positions
Count[list,patt] Number of matches
Min[list], Max[list] Min, max of list
Append[expr,elem] expr with elem added at end
AppendTo[expr,elem] Append and update expr
Prepend[expr,elem] Inset at beginning
Insert[list,elem,n] Insert elem in list at pos n
Delete[expr,elem,n] Delete elem in list at pos n
ReplacePart[expr,i->new] Replaces expr[[i]] by new
ReplaceList[expr,rule] Replace according to rule
Flatten[list] Flattens nested lists
Flatten[list,n] Flattens to level n
Take[list,n] Take first n elem
Take[#,1]&/@{{1,2},{3,1}}
Cases[list,patt] Elems of list matching patt
Cases[{2,xˆ 2},xˆ n ]
Cases[list,patt,n] First n matching patt
Cases[list,rule] Results for which rule applies
Select[list,boolean] Boolean selection in list
Position[expr,patt] Pos where patt appears
Join[l1,l2,...] Join lists
Union[l1,l2,...] Set union
Riffle[{e1,e2,...},x] {e1,x,e2,x,...}
Intersection[l1,l2,...] Set intersection
Subsets[list] All subsets of list
DeleteDuplicates Delete duplicates from list
Thread[f[{a,b,c}]] {f[a],f[b],f[c]}
Sort[list] Sorts list
Reverse[list] list in reverse order
PadLeft[list,n,x] Add x n times left of list
PadRight[list,n,x] Add x n times right of list
Partition[list,n] Partition list in n sublists
Split[list] Splits list in identical elems
Tuples[list,n] n-tuples of list
Permutations[list] Permutations
Outer[f,l1,l2] Outer (cartesian) product
Multiple counters possible
Same as Part[list,i] or list[[i]] MemberQ[list,patt]
Same as list[[i]][[j]]
Same as Part[list,i;;j]
Last if -n
Output: {2, 5}
Same as Array[#&,n]
Same as: Min[i,j,...]
Same as expr=Append[expr,elem] LetterQ[str]
See also: PrependTo
Output: {{1},{3}}
Output: x2
Same as ∪
Same as ∩
Pad with 0 if no x
Dynamic objects [ DC, Tut2 ]
Boolean functions [DC]
SameQ[x,y]
OrderedQ[list]
IntegerQ[x]
MatchQ[expr,patt]
ValueQ[expr]
AtomQ[expr]
FreeQ[expr,patt]
EvenQ[n]
OddQ[n]
PrimeQ[n]
NumberQ[expr]
NumericQ[expr]
PolynomialQ[expr,var]
VectorQ[expr]
MatrixQ[expr]
DigitQ[str]
Strings [DC, Tut]
"chars"
ToString[expr]
StringJoin[str1,str2,...]
StringLength[str]
StringTake[str,n]
StringDrop[str,n]
StringInsert[str1,str2,n]
StringPosition[str,substr]
StringCount[str,substr]
StringReplace[str,rule]
StringMatchQ[str,patt]
StringFreeQ[str,patt]
StringSplit[str]
StringSplit[str,patt]
Sort
DateString["elem"]
Characters[str]
ToUpperCase[str]
ToLowerCase[str]
CharacterRange["char1","char2"]
patt..
Whitespace
Dynamic[expr]
DynamicModule[{vars},...]
Manipulate[expr,{u,...}]
Programming [DC, Tut1, Tut2]
Same? (x===y) Do[expr,cnt] Do loop
list ordered? While[test,body] While loop
x integer? If[cond,t,f] If statement
Elems match patt? Return[expr] Output expr and stop
expr matches patt? Module[{x,...},expr] Proc with local vars
expr has value? (vars localization)
expr is atomic? Block[{x,...},expr] Eval with global vars
expr free of patt? With[{x=x0,...},expr] Local constants
n even integer? Trace[expr] Trace eval of expr
n odd integer? Compile[{vars},expr] Compiled expr
n prime integer?
expr a number? i++ Incrementation
expr numerical? i-- Decrementation
expr a polynomial? i+=di Increment by di
expr 1D array (list)? i-=di Decrement by di
expr 2D array (list)? i*=c Multiply by c and override val
All digits in str? i/=c Divide by c and override val
All letters in str?
String
Transforms expr to string
Join strings Same as <>
Number of chars in str
n first chars of str Last if -n
First n chars dropped Last if -n
Insert str2 at pos n
Start and end of substr in str
Number of occurrences of substr
Replace with rule
patt appears in str?
str free of patt?
Split where whitespace
Split according to patt
Alphabetical (canonical) sort
String version of date
List of chars
Capitalize
Lower case
List from char1 to char2
patt followed by symbols
White space
Dynamically updated expr
Module with dynamical vars
Interactive widget
Useful functions Linear algebra [DC] Parallel computation [DC, Tut]
Sum[f,{i,imin,imax,di}] Sum a.b Dot or matrix product Parallelize[expr] Direct parallelization
Product[f,{i,imin,imax,di}] Product Cross[a,b] Cross product ParallelEvaluate[expr] Eval on kernels
Mod[m,n] Remainder of m/n Norm[a] Euclidean norm DistributeDefinitions Put def on kernels
Solve[f[x]==0,x] Solves polynomial eqn IdentityMatrix[n] n × n identity matrix ParallelNeeds Package on kernels
Expand[p] Expand polynomial p Diagonal[m] Diagonal of m ParallelMap Parallel Map
ComplexExpand[expr] Expand expression (takes care of complex conjugates) Diagonal[m,k] kth elem in diagonal of m ParallelSum Parallel Sum
Factor[p] Factorize p Dimensions[m] Dimensions of m ParallelProduct Parallel Product
Length[expr] Number of elems in expr Inverse[m] Inverse square matrix m ParallelTable Parallel Table
Numerator[expr] Numerator of expr Det[m] Determinant square matrix ParallelDo Parallel Do
Denominator[expr] Denominator of expr Tr[m] Trace matrix or tensor m ParallelSubmit Submit to kernel
Options[cmd] Display options for cmd Transpose[l] Transpose first two levels Collect with WaitAll
SetOptions[cmd] Set options for cmd Eigenvalues[m] Eigenvals square matrix WaitAll Results from kernels
Evaluate[expr] Explicit eval Eigenvectors Eigenvects square matrix
Piecewise[{{val,test},...}] Piecewise definition
Numerical routines [DC, Tut]
InverseFunction[f][x] Inverse fct
Nest[f,x,n] n-fold fct composition N[expr] Numerical eval of expr
NestList[f,x,n] List of compositions SetPrecision[expr,n] Precision to n digits $Pre=SetPrecision[#,n]&
FixedPoint[f,x] Iterate until fixed point Set session precision to n digits
FixedPointList[f,x] Iteration list NSolve[eqn,var] Approx polynomial eqn
NestWhile[f,x,test] While iteration FindRoot[eqn,{x,x0}] Approx eqn in var x with seed x0
NestWhileList While iteration list FindRoot[eqn,{x,x0,a,b}] Approx eqn in [a, b]
LinearModelFit Linear model NDSolve[eqn,y,{x,a,b}] Solve differential eqn Initial cond specified in eqn
NonlinearModelFit Nonlinear model NIntegrate[f,{x,a,b}] Numerical integration. Methods:
GraphPlot[m] Graph (network) for adjacency m "SymbolicProcessing"->0 Fully numerical eval
GraphData["name"] Graph with name "GlobalAdaptive" Default
FinancialData["tag","date"] Financial data from date "LocalAdaptive"
CountryData["tag","prop"] Country data "Oscillatory" 1D integrals; automatic detection
WeatherData["tag","prop"] Weather data "PrincipalValue" Cauchy principal value
"MonteCarlo" Random sampling
Probability and statistics [DC] "AdaptiveMonteCarlo"
FindMinimum[f,x,x0] Find local min with seed x0
RandomReal[{a,b}] Uniform rand real in [a, b] From [0, 1] if no arg
NMinimize[f,x] Find global min. Methods:
RandomReal[dist] Rand real from dist
"DifferentialEvolution" Option: "SearchPoints"
RandomInteger[{i,j}] Uniform integer in [i, j] Uniform 0 or 1 if no arg
"NelderMead"
RandomInteger[dist] Rand integer from dist
"RandomSearch" Option: "SearchPoints"
RandomSample[list,n] n samples from list
"SimulatedAnnealing" Option: "SearchPoints"
RandomSeed[] Reset seed NumericalCalculus package:
PDF[dist,x] Density fct of dist NLimit[expr,x->x0] Numerical limit
CDF[dist,x] Cumulant density fct of dist ND[expr,x,x0] Numerical D at x0
Histogram[list,w] Histogram (bin width w) Option:"Probability" NSeries[f,{x,x0,n}] Numerical series
"ProbabilityDensity"
BinCounts[list,w] Counting dist of list (bin width w) Other
Mean[list] Also Mean[dist]
$Pre Pre-processing var
Variance[list]
$Post Post-processing var
StandardDeviation[list]
ChiSquareDistribution[ν]
ExponentialDistribution[λ]
NormalDistribution[µ,σ]
BinomialDIstribution[n,p]
BernoulliDistribution[p]
Some new/updated in Mathematica 8 Notes
Free form input Type = then input
WolframAlpha["query"] Query to WolframAlpha server

RandomVariate[dist] Merges RandomReal and RandomInteger

Probability[pred,x≈dist]
NProbability
Expectation[expr,x≈dist]
NExpectation
EstimatedDistribution[data,dist]
EmpiricalDistribution[data]
HistorgramDistributon
Distributed[x,dist]
Conditioned[expr,cond]
Cumulant[dist,r]
MomentGeneratingFunction[dist,t]
StableDistribution[type,α, β, µ, σ]
TransformedDistribution[trans,dist]
Probability of predicate with distribution dist
Expected value with distribution dist
Fit dist to data
Distribution for data
Similar to Histogram
x≈dist. Same as Esc -dist- Esc
expr conditioned on cond. Same as Esc -cond- Esc
rth cumulant of dist
Moment function in var t
Stable (Lévy) distribution

Graph
GraphPlot
GraphStyle
AdjacencyGraph
IncidenceGraph
GridGraph
RandomGraph
ButterflyGRaph
HighlightGraph
AdjacencyMatrix
VertexDegree
ClosenessCentrality
BetweennessCentrality
PageRankCentrality
GraphQ
ConnectedGraphQ

SmoothHistogram
SmoothHistogram3D
DensityHistogram
SmoothDensityHistogram

Texture Use image for plot rendering

TextRecognize Text recognition from image
Speak Speak content
SpokenString
ImageCapture[] Open camera utility
CurrentImage[] Returns current image
EdgeDetect[img] Returns image with edges Copyright c 2014 Hugo Touchette
Available at: http://www.physics.sun.ac.za/˜htouchette
Mathematica is a trademark of Wolfram Research