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

approx Approximation
arg Argument Blank: any expr
char Character Double blank: any seq of expr
See last page for Mathematica 8 updates cnt Counter
cond Condition Triple blank: zero or more args
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] Boolean functions [DC] Programming [DC, Tut1, Tut2]
{i,imax} Simple counter from 1 to imax SameQ[x,y] Same? (x===y) Do[expr,cnt] Do loop
{i,imin,imax,di} Counter with step di OrderedQ[list] list ordered? While[test,body] While loop
Table[expr,cnt] Generate list Multiple counters possible IntegerQ[x] x integer? If[cond,t,f] If statement
list[[i]] ith elem (list or expr) Same as Part[list,i] or list[[i]] MemberQ[list,patt] Elems match patt? Return[expr] Output expr and stop
list[[i,j]] (i, j) elem Same as list[[i]][[j]] MatchQ[expr,patt] expr matches patt? Module[{x,...},expr] Proc with local vars
list[[i;;j]] Range i to j Same as Part[list,i;;j] ValueQ[expr] expr has value? (vars localization)
Drop[list,n] First n elems dropped Last if -n AtomQ[expr] expr is atomic? Block[{x,...},expr] Eval with global vars
Drop[list,{n}] nth elem dropped FreeQ[expr,patt] expr free of patt? With[{x=x0,...},expr] Local constants
Extract[expr,list] Extract in expr at pos list EvenQ[n] n even integer? Trace[expr] Trace eval of expr
Array[f,n] {f (1), f (2), . . . , f (n)} OddQ[n] n odd integer? Compile[{vars},expr] Compiled expr
Array[1+#ˆ 2&,2] Output: {2, 5} PrimeQ[n] n prime integer?
Range[n] {1, 2, 3, . . . , n} Same as Array[#&,n] NumberQ[expr] expr a number? i++ Incrementation
Range[nmin,nmax,dn] Full syntax NumericQ[expr] expr numerical? i-- Decrementation
Position[expr,patt] List matching positions PolynomialQ[expr,var] expr a polynomial? i+=di Increment by di
Count[list,patt] Number of matches VectorQ[expr] expr 1D array (list)? i-=di Decrement by di
Min[list], Max[list] Min, max of list Same as: Min[i,j,...] MatrixQ[expr] expr 2D array (list)? i*=c Multiply by c and override val
Append[expr,elem] expr with elem added at end DigitQ[str] All digits in str? i/=c Divide by c and override val
AppendTo[expr,elem] Append and update expr Same as expr=Append[expr,elem] LetterQ[str] All letters in str?
Prepend[expr,elem] Inset at beginning See also: PrependTo Strings [DC, Tut]
Insert[list,elem,n] Insert elem in list at pos n
Delete[expr,elem,n] Delete elem in list at pos n "chars" String
ReplacePart[expr,i->new] Replaces expr[[i]] by new ToString[expr] Transforms expr to string
ReplaceList[expr,rule] Replace according to rule StringJoin[str1,str2,...] Join strings Same as <>
Flatten[list] Flattens nested lists StringLength[str] Number of chars in str
Flatten[list,n] Flattens to level n StringTake[str,n] n first chars of str Last if -n
Take[list,n] Take first n elem StringDrop[str,n] First n chars dropped Last if -n
Take[#,1]&/@{{1,2},{3,1}} Output: {{1},{3}} StringInsert[str1,str2,n] Insert str2 at pos n
Cases[list,patt] Elems of list matching patt StringPosition[str,substr] Start and end of substr in str
Cases[{2,xˆ 2},xˆ n ] Output: x2 StringCount[str,substr] Number of occurrences of substr
Cases[list,patt,n] First n matching patt StringReplace[str,rule] Replace with rule
Cases[list,rule] Results for which rule applies StringMatchQ[str,patt] patt appears in str?
Select[list,boolean] Boolean selection in list StringFreeQ[str,patt] str free of patt?
Position[expr,patt] Pos where patt appears StringSplit[str] Split where whitespace
Join[l1,l2,...] Join lists StringSplit[str,patt] Split according to patt
Union[l1,l2,...] Set union Same as ∪ Sort Alphabetical (canonical) sort
Riffle[{e1,e2,...},x] {e1,x,e2,x,...} DateString["elem"] String version of date
Intersection[l1,l2,...] Set intersection Same as ∩ Characters[str] List of chars
Subsets[list] All subsets of list ToUpperCase[str] Capitalize
DeleteDuplicates Delete duplicates from list ToLowerCase[str] Lower case
Thread[f[{a,b,c}]] {f[a],f[b],f[c]} CharacterRange["char1","char2"] List from char1 to char2
Sort[list] Sorts list patt.. patt followed by symbols
Reverse[list] list in reverse order Whitespace White space
PadLeft[list,n,x] Add x n times left of list Pad with 0 if no x
Dynamic objects [ DC, Tut2 ]
PadRight[list,n,x] Add x n times right of list
Partition[list,n] Partition list in n sublists Dynamic[expr] Dynamically updated expr
Split[list] Splits list in identical elems DynamicModule[{vars},...] Module with dynamical vars
Tuples[list,n] n-tuples of list Manipulate[expr,{u,...}] Interactive widget
Permutations[list] Permutations
Outer[f,l1,l2] Outer (cartesian) product
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] Probability of predicate with distribution dist
NProbability
Expectation[expr,x≈dist] Expected value with distribution dist
NExpectation
EstimatedDistribution[data,dist] Fit dist to data
EmpiricalDistribution[data] Distribution for data
HistorgramDistributon Similar to Histogram
Distributed[x,dist] x≈dist. Same as Esc -dist- Esc
Conditioned[expr,cond] expr conditioned on cond. Same as Esc -cond- Esc
Cumulant[dist,r] rth cumulant of dist
MomentGeneratingFunction[dist,t] Moment function in var t
StableDistribution[type,α, β, µ, σ] Stable (Lévy) distribution
TransformedDistribution[trans,dist]

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