Numerical Analysis Software: Fortran, MATLAB, R, NumPy

a side-by-side reference sheet

arithmetic and logic | strings | dates and time | multidimensional arrays | tuples, dictionaries, sequences | functions
execution control | environment and i/o | libraries and modules | reflection

vectors | matrices | statistics | distributions | data sets | univariate charts | bivariate charts | trivariate charts | contact

fortran (1957) matlab (1984) r (2000) numpy (2005)
version used GNU Fortran 4.5 (Fortran 95) Octave 3.2 2.6 Python 2.7
NumPy 1.6
SciPy 0.10
Matplotlib 1.0
implicit prologue none none none import sys, os, re, math
import numpy as np
import scipy as sp
import scipy.stats as stats
import matplotlib as mpl
import matplotlib.pyplot as plt
get version $ gfortran --version $ octave --version $ r --version sys.version
command line repl none $ octave $ r $ python
none $ octave foo.m $ r -f foo.r $ python
$ gfortran foo.f90 -o foo none none none
statement separator newline

when a line ends with & the statement continues on the following line
; or newline ; or sometimes newline newline or ;

newlines not separators inside (), [], {}, triple quote literals, or after backslash: \
block delimiters program end program
function end function
subroutine end subroutine
if then elseif then else endif
do while end do
do end do
function endfunction
if elseif else endif
while endwhile
do until
for endfor
{ } offside rule
assignment i = 3 i = 3 i = 3
i <- 3
3 -> i
i = 3
compound assignment operators: arithmetic, string, logical none MATLAB has no compound assignment operators. Octave has these:
+= -= *= /= none none **= or ^=
none none
&= |= none
none # do not return values:
+= -= *= /= //= %= **=
+= *=
&= |= ^=
increment and decrement operator none ++x --x
x++ x--
none none
to-end-of-line comment i = 1 + 1 ! addition 1 + 1 % addition
Octave only:
1 + 1 # addition
1 + 1 # addition 1 + 1 # addition
null only used in place of numeric values:
null test isna(v)
true for '', []:
v == None
v is None
undefined variable access variables must be declared under implicit none raises error raises error raises NameError
variable types integer real complex character logical
variable declaration integer :: n
real :: x = 3.7
none none none
are identifiers case sensitive no; Fortran 77 and earlier required all caps yes yes yes
arithmetic and logic
fortran matlab r numpy
true and false
.true. .false. 1 0 true false TRUE FALSE T F True False
falsehoods .false.
no implicit conversion of values to booleans
false 0 0.0
matrices evaluate to false unless nonempty and all entries evaluate to true
FALSE F 0 0.0
matrices evaluate to value of first entry; string in boolean context causes error
False None 0 0.0 '' [] {}
logical operators .and. .or. .not. .eqv. .neqv. ~true | (true & false)
Optional negation operator in Octave: !
short-circuit operators:
&& ||
short-circuit operators:
&& ||
and or not
conditional expression none none (if (x > 0) x else -x)
ifelse(x > 0, x, -x)
x if x > 0 else -x
convert from string, to string 7 + str2num('12')
73.9 + str2num('.037')
horzcat('value: ', num2str(8))
7 + as.integer("12")
73.9 + as.double(".037")
paste("value: ", toString("8"))
7 + int('12')
73.9 + float('.037')
'value: ' + str(8)
comparison operators == /= > < >= <= == ~= > < >= <=
Optional inequality operator in Octave: !=
== != > < >= <= == != > < >= <=
arithmetic operators + - * none / mod(n, divisor) ** + - * / none mod(n, divisor) ** or ^ + - * / ? ? ** or ^ + - * / // % **
integer division
13 / 5 fix(13 / 5) as.integer(13 / 5) 13 // 5
float division
real(13) / 5 13 / 5 13 / 5 float(13) / 5
arithmetic functions sqrt exp log sin cos tan asin acos atan atan2 sqrt exp log sin cos tan asin acos atan atan2 sqrt exp log sin cos tan asin acos atan atan2 math.sqrt math.exp math.log math.sin math.cos math.tan math.asin math.acos math.atan math.atan2
arithmetic truncation int(3.7)
fix round ceil floor as.integer round ceiling floor int(x)
arithmetic decomposition abs(-3.7)
sign(1.0, -3.7)
atan2(imag(z), real(z))
abs sign real imag arg abs sign Re Im Arg import cmath

math.copysign(1, -3.7)
closure of integers under division integers floats floats integers
integer overflow modular arithmetic becomes float; largest representable integer in the variable intmax becomes float; largest representable integer in the variable .Machine$integer.max becomes arbitrary length integer of type long
float overflow
Inf Inf raises OverflowError
float limits
1/0 real :: x = 0.0
! compiler error:
1.0 / 0.0
! +Infinity:
1.0 / x
Inf Inf raises ZeroDivisionError
sqrt(-2) real :: x = -2.0
complex :: z = (-2.0, 0.0)
! compiler error:
! NaN:
! (0.000, 1.414)
0.00000 + 1.41421i
# raises ValueError:

# returns 1.41421j:
import cmath
complex numbers (0.0, 1.0)
(0.0, 2.0)
(0.0, 3.0)
random integer
floor(100*rand) floor(100*runif(1)) np.random.randint(0,100)
random float
rand(0) rand runif(1) np.random.rand()
setting seed
rand('state', 17) set.seed(17) np.random.seed(17)
result of not seeding the same after each run seeded using operating system entropy seeded using current time on Unix reads seed from /dev/random
fortran matlab r numpy
literal 'don''t say "no"'
"don't say ""no"""
'don''t say "no"'
Octave also has double quoted strings:
"don't say \"no\""
"don't say \"no\""
'don\'t say "no"'
'don\'t say "no"'
"don't say \"no\""
r"don't " r'say "no"'
newline in literal
"lorem" // achar(10) // "ipsum" no; use \n escape yes no
literal escapes none \\ \" \' \0 \a \b \f \n \r \t \v \\ \" \' \a \b \f \n \r \t \v \ooo single and double quoted:
\newline \\ \' \" \a \b \f \n \r \t \v \ooo \xhh
character access
"hello"(1:1) 'hello'(1) substr("hello",1,1) 'hello'[0]
chr and ord achar(65)
len("hello") length('hello') nchar("hello") len('hello')
concatenate 'one ' // 'two ' // 'three' horzcat('one ', 'two ', 'three') paste("one ", "two ", "three") 'one ' + 'two ' + 'three'
literals, but not variables, can be concatenated with juxtaposition:
'one ' "two " 'three'
replicate character(len=80) :: hbar
hbar = repeat('-', 80)
hbar = repmat('-', 1, 80) hbar = paste(rep('-',80),collapse='') hbar = '-' * 80
index of substring counts from one, returns
zero if not found

index("hello", "el")
counts from one, returns
zero if not found

index('hello', 'el')
counts from one, returns
-1 if not found

regexpr("el", "hello")
counts from zero, raises ValueError if not found:
extract substring
"hello"(1:4) substr('hello',1,4) substr("hello",1,4) 'hello'[0:4]
split none returns tuple:
strsplit('foo,bar,baz', ',') 'foo,bar,baz'.split(',')
join paste("foo", "bar", "baz", sep=",")
trim ??
adjustl(' foo')
trim('foo ')
strtrim(' foo ')
deblank('foo ')
gsub("(^[\n\t ]+|[\n\t ]+$)",
  " foo ")
sub("^[\n\t ]+", "", " foo")
sub("[\n\t ]+$", "", "foo ")
' foo '.strip()
' foo'.lstrip()
'foo '.rstrip()
case manipulation none lower('FOO')
sprintf character(len=100) :: s
write(s,'(A A F9.3 I9)') 'foo', ':', 2.2, 7
sprintf('%s: %.3f %d', 'foo', 2.2, 7) sprintf("%s: %.3f %d", "foo", 2.2, 7) '%s: %.3f %d' % ('foo',2.2,7)
regex test none regexp('hello','^[a-z]+$')
regexpr("^[a-z]+$", "hello") > 0
regexpr('^\\S+$', "hello",perl=T) > 0'^[a-z]+$', 'hello')'^\S+$', 'hello')
regex substitution none regexprep('foo bar bar','bar','baz','once')
regexprep('foo bar bar','bar','baz')
sub('bar','baz','foo bar')
gsub('bar','baz','foo bar bar')
rx = re.compile('bar')
s = rx.sub('baz', 'foo bar', 1)
s2 = rx.sub('baz', 'foo bar bar')
dates and time
fortran matlab r numpy
current date/time GNU Fortran:
t = time()
t = now t = as.POSIXlt(Sys.time())
date/time type integer representing seconds since Jan 1, 1970 UTC floating point number representing days since year 0 in the Gregorian calendar POSIXlt
date/time difference type integer representing seconds floating point number representing days a difftime object which behaves like a floating point number representing seconds
get date parts integer::values(9);
integer year,mon,day

call ltime(t, values)
year = values(6) + 1900
mon = values(5) + 1
day = values(4)
t$year + 1900
t$mon + 1
get time parts integer::values(9)
integer hour,min,sec

call ltime(t, values)
hour = values(3)
min = values(2)
sec = values(1)
build date/time from parts none t = datenum([2011 9 20 23 1 2]) t = as.POSIXlt(Sys.time())
t$year = 2011 - 1900
t$mon = 9 - 1
t$mday = 20
t$hour = 23
t$min = 1
t$sec = 2
convert to string
ctime(t) datestr(t) print(t)
strptime none t = datenum('2011-09-20 23:01:02',
  'yyyy-mm-dd HH:MM:SS')
t = strptime('2011-09-20 23:01:02',
  '%Y-%m-%d %H:%M:%S')
none datestr(t, 'yyyy-mm-dd HH:MM:SS') format(t, format='%Y-%m-%d %H:%M:%S')
multidimensional arrays
fortran matlab r numpy
array literal integer::a(3) = (/ 1, 2, 3 /) [1,2,3]
commas are optional:
[1 2 3]
c(1,2,3) np.array([1,2,3])
2d array literal integer::a(2,2) = &
  reshape((/ 1, 2, 3, 4 /), &
  (/ 2, 2 /))
spaces and newlines can replace commas and semicolons:
[1 2
 3 4]
array(c(1,2,3,4),dim=c(2,2)) np.array([[1,2],[3,4]])
3d array literal A = [1,2;3,4]
A(:,:,2) = [5,6;7,8]
array(c(1,2,3,4,5,6,7,8),dim=c(2,2,2)) np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
must arrays be homogeneous yes yes yes yes
array data type depends on declaration; no run time type inspection always numeric class(c(1,2,3))

a = array(c(1,2,3))
data types permitted in arrays any but type must be declared numeric boolean, numeric, string np.bool, np.int64, np.float64, np.complex128, and others
array element access ! indices start at one
a = (/ 1, 2, 3 /)
indices start at one:
[1 2 3](1)
indices start at one:
indices start at zero:
a = np.array([1,2,3])
index of array element which(c(7,8,9)==9)
array slice ! can't slice literal

a1 = (/1,2,3/)
a2 = a1(1:2)
[1 2 3](1:2) c(1,2,3)[1:2] np.array([1,2,3])[0:2]
integer array as index [1 2 3]([1,3,3]) c(1,2,3)[c(1,3,3)] np.array([1,2,3])[[0,2,2]]
logical array as index [1 2 3]([true false true]) c(1,2,3)[c(T,F,T)] np.array([1,2,3])[[True,False,True]]
array length
size((/ 1, 2, 3 /)) length([1 2 3]) length(c(1,2,3)) len(np.array([1,2,3]))
multidimensional array size length(dim(a))
array concatenation cat(2, [1 2 3], [4 5 6])
horzcat([1 2 3], [4 5 6])
append(c(1,2,3),c(4,5,6)) a1 = np.array([1,2,3])
a2 = np.array([4,5,6])
sort a = [3 1 4 2]
a = sort(a)
a = c(3,1,4,2)
a = sort(a)
a = np.array([3,1,4,2])
map arrayfun( @(x) x*x, [1 2 3]) sapply(c(1,2,3), function (x) { x * x}) a = np.array([1,2,3])
np.vectorize(lambda x: x*x)(a)
filter v = [1 2 3]
v(v > 2)
v = c(1,2,3)
v[v > 2]
v = np.array([1,2,3])
a = [x for x in v if x > 2]
sample w/o replacement x = c(3,7,5,12,19,8,4)
sample(x, 3)
from random import sample

sample([3,7,5,12,19,8,4], 3)
tuples, dictionaries, sequences
fortran matlab r numpy
tuple literal
none tup = {1.7, 'hello', [1 2 3]} tup = list(1.7,"hello",c(1,2,3)) tup = (1.7, "hello", [1,2,3])
tuple element access none tup{1} tup[[1]] tup[0]
tuple length
none length(tup) length(tup) len(tup)
dictionary literal
none d = struct('n',10,'avg',3.7,'sd',0.4) d = list(n=10, avg=3.7, sd=0.4) d = {'n':10, 'avg':3.7, 'sd':0.4}
dictionary lookup
none d.n d$n d['n']
range 1:100 1:100
range(1, 101)
arithmetic sequence of integers with difference 10 0:10:100 seq(0,100,10) range(0, 101, 10)
arithmetic sequence of floats with difference 0.1 0:0.1:10 seq(0,10,0.1) [0.1*x for x in range(0,101)]

3rd arg is length of sequence, not step size:
sp.linspace(0, 10, 100)
fortran matlab r numpy
definition integer function add(n, m)
  integer, intent(in) :: n
  integer, intent(in) :: m
  add = n + m
end function add
function add(a,b)
add = function(a,b) {a + b}
add(3, 7) add(3, 7) add(3, 7)
return value assign to implicit variable with same name as function; can use return statement to terminate function execution how to declare a return variable:
function retvar = add(a,b)
  retvar = a + b

the return value is the value assigned to the return variable if one is defined; otherwise it's the last expression evaluated.
return argument or last expression evaluated. NULL if return called without an argument.
function value none; function pointers added in Fortran 2003 @add add
anonymous function none; see above @(a,b) a+b function(a,b) {a+b}
missing argument set to zero raises error if code with the parameter that is missing an argument is executed raises error
extra argument
ignored ignored raises error
default argument real function mylog(x, base)
  real :: x
  real, optional :: base
  if (present(base)) then
    mylog = log(x) / log(base)
    mylog = log(x) / log(10.0)
end function mylog
function mylog(x, base=10)
  log(x) / log(base)
mylog = function(x,base=10) {
  log(x) / log(base)
variable number of arguments none function s = add(varargin)
  if nargin == 0
    s = 0
    r = add(varargin{2:nargin})
    s = varagin{1} + r
add = function (...) {
  a = list(...)
  if (length(a) == 0)
  s = 0
  for(i in 1:length(a)) {
    s = s + a[[i]]
execution control
fortran matlab r numpy
if if (n == 0) then
  write(*,*) 'no hits'
elseif (n == 1) then
  write(*,*) 'one hit'
  write(*,*) n, 'hits'
if (x > 0)
elseif (x < 0)
if (x > 0) {
} else if (x < 0) {
} else {
if x > 0:
elif x < 0:
while n = 1
do while ( n < 10 )
  write(*,*) n
  n = n + 1
end do
i = 0
while (i < 10)
  printf('%d\n', i)
while (i < 10) {
  i = i + 1
while i < 10:
  i += 1
for do n = 1, 10, 1
  write(*,*) n
end do
for i = 1:10
  printf('%d\n', i)
for (i in 1:10) {
for i in range(1,11):
exit cycle break continue break next break continue
raise exception write(0, "failed")
call exit(-1)
error('%s', 'failed') stop('failed') raise Exception('failed')
handle exception none try
  printf('%s\n', lasterr())
  error=function(e) print(message(e)))
  raise Exception('failed')
except Exception as e:
finally block none unwind_protect
  if ( rand > 0.5 )
risky = function() {
  if (runif(1) > 0.5) {
environment and i/o
fortran matlab r numpy
write to stdout write(*,*) 'hello' printf('hello\n') print('hello')
read entire file into string or array con = file("/etc/hosts", "r")
a = readLines(con)
redirect to file sink("foo.txt")
libraries and modules
fortran matlab r numpy
load library % if installed as Octave package:
pkg load foo
require("foo") or
import foo
list loaded libraries none none search() dir()
library search path path()
.libPaths() sys.path
source file
none source('foo.m') source("foo.r") none
install package none % installs packages downloaded from
% Octave-Forge in Octave:

pkg install foo-1.0.0.tar.gz
install.packages("ggplot2") $ pip install scipy
list installed packages none pkg list library() $ pip freeze
fortran matlab r numpy
data type none, but variable type must be declared class(x) class(x) type(x)
attributes none, and Fortran 95 does not have objects if x is an object value:
attributes(x) [m for m in dir(x)
  if not callable(getattr(o,m))]
methods none note that most values are not objects:
none; objects are implemented by functions which dispatch based on type of first arg [m for m in dir(x)
  if callable(getattr(o,m))]
variables in scope none who() objects() dir()
undefine variable
none clear('x') rm(v) del(x)
none eval('1+1') eval(parse(text='1+1')) eval('1+1')
function documentation none help tan help(tan)
list library functions none none ls("package:moments") dir(stats)
search documentation none not in Octave:
docsearch tan
??tan $ pydoc -k tan
fortran matlab r numpy
vector literal same as array same as array same as array same as array
element-wise arithmetic operators + - * / + - .* ./ + - * / + - * /
result of vector length mismatch compilation error raises error values in shorter vector are recycled; warning if one vector is not a multiple length of the other raises ValueError
scalar multiplication 3 * (/1,2,3/)
(/1,2,3/) * 3
3 * [1,2,3]
[1,2,3] * 3
3 * c(1,2,3)
c(1,2,3) * 3
3 * np.array([1,2,3])
np.array([1,2,3]) * 3
dot product dot_product((/1,1,1/),(/2,2,2/)) dot([1,1,1], [2,2,2]) c(1,1,1) %*% c(2,2,2) v1 = np.array([1,1,1])
v2 = np.array([2,2,2]),v2)
cross product cross([1,0,0], [0,1,0]) v1 = np.array([1,0,0])
v2 = np.array([0,1,0])
norms norm([1,2,3], 1)
norm([1,2,3], 2)
norm([1,2,3], Inf)
vnorm = function(x, t) {
  norm(matrix(x, ncol=1), t)

vnorm(c(1,2,3), "1")
vnorm(c(1,2,3), "E")
vnorm(c(1,2,3), "I")
v = np.array([1,2,3])
np.linalg.norm(v, 1)
np.linalg.norm(v, 2)
np.linalg.norm(v, np.inf)
fortran matlab r numpy
literal or constructor column contiguous:
integer::A(2,2) = &
  reshape((/ 1, 3, 2, 4 /), &
  (/ 2, 2 /))

integer::B(2,2) = &
  reshape((/ 4, 2, 3, 1 /), &
  (/ 2, 2 /))
row contiguous:
A = [1,2;3,4]
B = [4 3
     2 1]
column contiguous:
A = matrix(c(1,3,2,4), 2, 2)
B = matrix(c(4,2,3,1), nrow=2)
row contiguous:
A = np.matrix([[1,2],[3,4]])
B = np.matrix([[4,3],[2,1]])
zero, identity, ones, diagonal matrix zeros(3,3) or zeros(3)
ones(3,3) or ones(3)
dimensions rows(A)
element access A(1,1) A[1,1] A[0,0]
row access A(1,1:2) A[1,] A[0]
column access A(1:2,1) A[,1]
submatrix access C = [1,2,3;4,5,6;7,8,9]
C = matrix(seq(1,9),3,3,byrow=T)
scalar multiplication 3 * A
A * 3
3 .* A
A .* 3
3 * A
A * 3
3 * A
A * 3
element-wise operators .+ .- .* ./ + - * / + - np.multiply() np.divide()
multiplication matmul(A, B) A * B A %*% B A * B
power A ** 3
kronecker product kron(A,B) kronecker(A,B) np.kron(A, B)
comparison all(all(A==B))
norms norm(A,1)
transpose transpose(A)
t(A) A.transpose()
conjugate transpose A = [1i,2i;3i,4i]
A = matrix(c(1i,2i,3i,4i), nrow=2, byrow=T)
A = np.matrix([[1j,2j],[3j,4j]])
inverse inv(A) solve(A) np.linalg.inv(A)
determinant det(A) det(A) np.linalg.det(A)
trace trace(A) sum(diag(A)) A.trace()
eigenvalues eig(A) eigen(A)$values np.linalg.eigvals(A)
eigenvectors [evec,eval] = eig(A)
eigen(A)$vectors np.linalg.eig(A)[1]
system of equations A \ [2;3] solve(A,c(2,3)) np.linalg.solve(A, [2,3])
fortran matlab r numpy
first moment statistics x = [1 2 3 8 12 19]

x = c(1,2,3,8,12,19)

x = [1,2,3,8,12,19]

second moment statistics std(x, 1)
var(x, 1)
n = length(x)

sd(x) * sqrt((n-1)/n)
var(x) * (n-1)/n
second moment statistics for samples std(x)
n = float(len(x))

sp.std(x) * math.sqrt(n/(n-1))
sp.var(x) * n/(n-1)
skewness Octave uses sample standard deviation to compute skewness:

kurtosis Octave uses sample standard deviation to compute kurtosis:

kurtosis(x) - 3
nth moment and nth central moment n = 5

moment(x, n)
moment(x, n, "c")

n = 5
moment(x, n)
moment(x, n, central=T)
n = 5

stats.moment(x, n)
mode mode([1 2 2 2 3 3 4]) samp = c(1,2,2,2,3,3,4)
quantile statistics min(x)
quantile(x, prob=.90)
stats.scoreatpercentile(x, 90.0)
linear regression y = ax + b x = [1 2 3]
y = [2 4 7]
[lsq, res] = polyfit(x, y, 1)

a = lsq(1)
b = lsq(2)
y - (a*x+b)
x = c(1,2,3)
y = c(2,4,7)
lsq = lm(y ~ x)

a = lsq$coefficients[2]
b = lsq$coefficients[1]
x = np.array([1,2,3])
y = np.array([2,4,7])
lsq = stats.linregress(x, y)

a = lsq[0]
b = lsq[1]
y - (a*x+b)
bivariate statistiscs x = [1 2 3]
y = [2 4 7]

cor(x, y)
cov(x, y)
x = c(1,2,3)
y = c(2,4,7)

cor(x, y)
cov(x, y)
x = [1,2,3]
y = [2,4,7]

stats.linregress(x, y)[2]
fortran matlab r numpy
binomial binopdf(x, n, p)
binocdf(x, n, p)
binoinv(y, n, p)
binornd(n, p)
dbinom(x, n, p)
pbinom(x, n, p)
qbinom(y, n, p)
rbinom(1, n, p)
stats.binom.pmf(x, n, p)
stats.binom.cdf(x, n, p)
stats.binom.ppf(y, n, p)
stats.binom.rvs(n, p)
poisson poisspdf(x, lambda)
poisscdf(x, lambda)
poissinv(y, lambda)
dpois(x, lambda)
ppois(x, lambda)
qpois(y, lambda)
rpois(1, lambda)
stats.poisson.pmf(x, lambda)
stats.poisson.cdf(x, lambda)
stats.poisson.ppf(y, lambda)
stats.poisson.rvs(lambda, size=1)
normal normpdf(x, mu, sigma)
normcdf(x, mu, sigma)
norminv(y, mu, sigma)
normrnd(mu, sigma)
dnorm(x, mu, sigma)
pnorm(x, mu, sigma)
qnorm(y, mu, sigma)
rnorm(1, mu, sigma)
stats.norm.pdf(x, mu, sigma)
stats.norm.cdf(x, mu, sigma)
stats.norm.ppf(y, mu, sigma)
stats.norm.rvs(mu, sigma)
gamma gampdf(x, k, theta)
gamcdf(x, k, theta)
gaminv(y, k, theta)
gamrnd(k, theta)
dgamma(x, k, scale=theta)
pgamma(x, k, scale=theta)
qgamma(y, k, scale=theta)
rgamma(1, k, scale=theta)
stats.gamma.pdf(x, k, scale=theta)
stats.gamma.cdf(x, k, scale=theta)
stats.gamma.ppf(y, k, scale=theta)
stats.gamma.rvs(k, scale=theta)
exponential exppdf(x, lambda)
expcdf(x, lambda)
expinv(y, lambda)
dexp(x, lambda)
pexp(x, lambda)
qexp(y, lambda)
rexp(1, lambda)
stats.expon.pdf(x, scale=1.0/lambda)
stats.expon.cdf(x, scale=1.0/lambda)
stats.expon.ppf(x, scale=1.0/lambda)
chi-squared chi2pdf(x, nu)
chi2cdf(x, nu)
chi2inv(y, nu)
dchisq(x, nu)
pchisq(x, nu)
qchisq(y, nu)
rchisq(1, nu)
stats.chi2.pdf(x, nu)
stats.chi2.cdf(x, nu)
stats.chi2.ppf(y, nu)
beta betapdf(x, alpha, beta)
betacdf(x, alpha, beta)
betainvf(y, alpha, beta)
betarnd(alpha, beta)
dbeta(x, alpha, beta)
pbeta(x, alpha, beta)
qbeta(y, alpha, beta)
rbeta(1, alpha, beta)
stats.beta.pdf(x, alpha, beta)
stats.beta.cdf(x, alpha, beta)
stats.beta.ppf(y, alpha, beta)
stats.beta.pvs(alpha, beta)
uniform unifpdf(x, a, b)
unifcdf(x, a, b)
unifinv(y, a, b)
unifrnd(a, b)
dunif(x, a, b)
punif(x, a, b)
qunif(y, a, b)
runif(1, a, b)
stats.uniform.pdf(x, a, b)
stats.uniform.cdf(x, a, b)
stats.uniform.ppf(y, a, b)
stats.unifrom.rvs(a, b)
Student's t dt(x, nu)
pt(x, nu)
qt(y, nu)
rt(1, nu)
stats.t.pdf(x, nu)
stats.t.cdf(x, nu)
stats.t.ppf(y, nu)
Snedecor's F df(x, d1, d2)
pf(x, d1, d2)
qf(y, d1, d2)
rf(1, d1, d2)
stats.f.pdf(x, d1, d2)
stats.f.cdf(x, d1, d2)
stats.f.ppf(y, d1, d2)
stats.f.rvs(d1, d2)
data sets
construct from arrays gender, height, weight of some
people in inches and lbs:

sx = c("F","F","F","F","M","M")
ht = c(69,64,67,66,72,70)
wt = c(150,132,142,139,167,165)
people = data.frame(sx, ht, wt)
view in spreadsheet can edit data, in which case return value of edit must be saved
people = edit(people)
list column names names(people)
attach column names copy columns into variables
sx, ht and wt:

detach column names detach(people)
column access vectors:
1 column data set:
row access 1 row data set:
access sub data set data set of first 3 rows with
ht and wt columns reversed

access datum datum in 1st row, 2nd column:
sort rows of data set people[order(people$ht),]
sort rows in descending order people[order(-people$ht),]
map data set convert to cm and kg:
transform(people, ht=2.54*ht, wt=wt/2.2)
filter data set subset(people, ht > 66)
people[people$ht > 66,]
load from csv
people = read.csv('/path/to.csv')
save as csv
show built-in data sets data()
load built-in data set data(iris)
univariate charts
matlab r matplotlib
5039793334_f76edece33_m.jpg vertical bar chart bar([7 3 8 5 5]) cnts = c(7,3,8,5,5)
names(cnts) = c("a","b","c","d","e")

x = floor(6*runif(100))
cnts = [7,3,8,5,5],len(cnts)), cnts)
horizontal bar chart
barh([7 3 8 5 5]) cnts = c(7,3,8,5,5)
names(cnts) = c("a","b","c","d","e")
barplot(cnts, horiz=T)
cnts = [7,3,8,5,5]
plt.barh(range(0,len(cnts)), cnts)
5037819710_d932767cd5_m.jpg pie chart labels = {'a','b','c','d','e'}
pie([7 3 8 5 5], labels)
cnts = c(7,3,8,5,5)
names(cnts) = c("a","b","c","d","e")
cnts = [7,3,8,5,5]
labs = ['a','b','c','d','e']
plt.pie(cnts, labels=labs)
5037283957_9499b8529a_m.jpg stacked dot chart stripchart(floor(10*runif(50)),
stem-and-leaf plot
generates an ascii chart:
5037415497_4c6fbfcab2_m.jpg histogram hist(randn(1,100),10) hist(rnorm(100),breaks=10) plt.hist(sp.randn(100),
5037525393_7ac86e81c3_m.jpg box-and-whisker plot boxplot(rnorm(100))


set chart title all chart functions except for stem accept a main parameter:
  main="boxplot example",
  sub="to illustrate options")
plt.title('boxplot example')
bivariate charts
matlab r matplotlib
stacked bar chart
d = [7 1; 3 2; 8 1; 5 3; 5 1]
bar(d, 'stacked')
d = matrix(c(7,1,3,2,8,1,5,3,5,1),
labels = c("a","b","c","d","e")
a1 = [7,3,8,5,5]
a2 = [1,2,1,3,1],5), a1, color='r'),5), a2, color='b')
grouped bar chart
d = [7 1; 3 2; 8 1; 5 3; 5 1]
d = matrix(c(7,1,3,2,8,1,5,3,5,1),
labels = c("a","b","c","d","e")
5267212089_a7749bbe3e_s.jpg scatter plot plot(randn(1,50),randn(1,50),'+') plot(rnorm(50), rnorm(50)) plt.scatter(sp.randn(50),
5267975488_2216ae147e_s.jpglinear regression line x = 0:20
y = 2 * x + rnorm(21)*10
o = lm(y ~ x)
x = range(0,20)
err = sp.randn(20)*10
y = [2*i for i in x] + err
A = np.vstack([x,np.ones(len(x))]).T
m, c = np.linalg.lstsq(A, y)[0]
plt.scatter(x, y)
plt.plot(x, [m*i + c for i in x])
5267434941_f8537c9d26_s.jpg polygonal line plot plot(1:20,randn(1,20)) plot(1:20, rnorm(20), type="l") plot(range(0,20), randn(20))
5268071368_75c3aee42e_t.jpg area chart
5268229340_0b96b5e223_s.jpg cubic spline f = splinefun(rnorm(20))
x = seq(1,20,.1)
5268208606_b745646ea6_s.jpg function plot fplot(@sin, [-4 4]) x = seq(-4,4,.01)
5267567389_27a19429e4_s.jpg quantile-quantile plot qqplot(runif(50),rnorm(50))
lines(c(-9,9), c(-9,9), col="red")
axis label plot(1:20, (1:20)^2, xlab="x", ylab="x squared")
axis limits plot(1:20, (1:20)^2, xlab="x", ylab="x squared", ylim=c(-200,500))
logarithmic y-axis x = 0:20
x = range(0, 20)

for i in [2,3,4,5]:
  y.append([j**i for j in x])

for i in [0,1,2,3]:
  semilogy(x, y[i])
trivariate charts
matlab r matplotlib
3d scatter plot
5268191292_a75a367c39_s.jpg additional data set plot(1:20, rnorm(20), type="l")
lines(1:20, rnorm(20), col="red")
bubble chart
surface plot
__________________________________________ __________________________________________ __________________________________________ __________________________________________

General Footnotes

version used

The version of software used to check the examples in the reference sheet.

implicit prologue

Code which examples in the sheet assume to have already been executed.

get version

How to determine the version of an installation.

command line repl

How to launch a command line read-eval-print loop for the language.


R installations come with a clickable GUI REPL.


How to invoke the interpreter on a script.


How to compile an executable.

statement separator

How statements are separated.


Use a backslash to escape a newline and continue a statement on the following line. MATLAB, in contrast, uses three periods: '…' to continue a statement on the following line.

block delimiters

Punctuation or keywwords which define blocks.


The list of keywords is not exhaustive.


The list of keywords which define blocks is not exhaustive. Blocks are also defined by

  • switch, case, otherwise, endswitch
  • unwind_protect, unwind_protect_cleanup, end_unwind_protect
  • try, catch, end_try_catch



Traditionally <- was used in R for assignment. Using an = for assignment was introduced in version 1.4.0 sometime before 2002. -> can also be used for assignment:

3 -> x

compound assignment operators: arithmetic, string, logical

The compound assignment operators.

increment and decrement operator

The operator for incrementing the value in a variable; the operator for decrementing the value in a variable.

to-end-of-line comment

Character used to start a comment that goes to the end of the line.



NA can be used for missing numerical values. Using a comparison operator on it always returns false, including NA == NA. Using a logical operator on NA raises an error.


Comparison operators return NA when one of the arguments is NA. In particular NA == NA is NA. When acting on values that might be NA, the logical operators observe the rules of ternary logic, treating NA is the unknown value.

null test

How to test if a value is null.

undefined variable access

What happens when a variable which hasn't been declared or defined is accessed.

variable types

The types which are available for variable declaration.

variable declaration

How to declare the type of a variable.

are identifiers case sensitive

Are identifiers case sensitive?

Arithmetic and Logic Footnotes

true and false

The boolean literals.


true and false are functions which return matrices of ones and zeros of type logical. If no arguments are specified they return single entry matrices. If one argument is provided, a square matrix is returned. If two arguments are provided, they are the row and column dimensions.


Values which evaluate to false in a conditional test.


When used in a conditional, matrices evaluate to false unless they are nonempty and all their entries evaluate to true. Because strings are matrices of characters, an empty string ('' or "") will evaluate to false. Most other strings will evaluate to true, but it is possible to create a nonempty string which evaluates to false by inserting a null character; e.g. "false\000".


When used in a conditional, a vector evaluates to the boolean value of its first entry. Using a vector with more than one entry in a conditional results in a warning message. Using an empty vector in a conditional, c() or NULL, raises an error.

logical operators

The boolean operators.


Note that MATLAB does not use the exclamation point '!' for negation.

&& and || are short circuit logical operators.

conditional expression

A conditional expression.

convert from string, to string

How to convert strings to numbers and vice versa.

comparison operators

The comparison operators.


Note that MATLAB does not use '!=' for an inequality test.

arithmetic operators

The arithmetic operators.


^ is a synonym for **.

mod is a function and not an infix operator. mod returns a positive value if the first argument is positive, whereas rem returns a negative value.


^ is a synonym for **.

integer division

How to compute the quotient of two integers.

float division

How to perform float division, even if the arguments are integers.

arithmetic functions

Some standard arithmetic functions.

arithmetic truncation

Ways of converting a float to a nearby integer.

arithmetic decomposition

Ways of decomposing numbers into a simpler type of number.

closure of integers under division

The data type of an expression which divides two integers.

integer overflow

What happens when an expression evaluates to an integer which is too big to be represented.

float overflow

What happens when an expression evaluates to a float which is too big to be represented.

float limits

The machine epsilon; the largest representable float and the smallest (i.e. closest to negative infinity) representable float.


The result of division by zero.


The result of taking the square root of a negative number.

complex numbers

Literals for complex numbers.

random integer

How to generate a random integer from a uniform distribution.

random float

How to generate a random float from a uniform distribution.

setting seed

How to set the seed used by the random number generator.

result of not seeding

What happens if no seed was set and a random number is generated.

String Footnotes


The syntax for a string literal.

newline in literal

Can a newline be included in a string literal? Equivalently, can a string literal span more than one line of source code?

literal escapes

Escape sequences for including special characters in string literals.

character access

How to get the character in a string at a given index.

chr and ord

How to convert an ASCII code to a character; how to convert a character to its ASCII code.


How to get the number of characters in a string.


How to concatenate strings.


How to create a string which consists of a character of substring repeated a fixed number of times.

index of substring

How to get the index of first occurrence of a substring.

extract substring

How to get the substring at a given index.


How to split a string into an array of substrings. In the original string the substrings must be separated by a character, string, or regex pattern which will not appear in the array of substrings.

The split operation can be used to extract the fields from a field delimited record of data.


How to join an array of substrings into single string. The substrings can be separated by a specified character or string.

Joining is the inverse of splitting.


How to remove whitespace from the beginning and the end of a string.

Trimming is often performed on user provided input.

case manipulation

How to put a string into all caps. How to put a string into all lower case letters. How to capitalize the first letter of a string.


How to create a string using a printf style format.


Fortran format strings use these expressions:

A character
Dwidth.precision double in scientific notation
Ewidth.precision real in scientific notation
Fwidth.precision real in fixed point notation
Iwidth integer
X space
nX repeat following format expression n times
/ newline

width and precision are integers. width is the field width in characters. Other characters in the format string are ignored.

regex test

How to test whether a string matches a regular expression.

regex substitution

How to replace all substring which match a pattern with a specified string; how to replace the first substring which matches a pattern with a specified string.

Date and Time Footnotes

current date/time

How to get the current date and time.


The Fortran 95 standard specifies two date functions: system_clock() and date_and_time().

system_clock() returns the number of clock ticks since an unspecified time. The number of ticks per second can be specified as an argument. Since the start time is unspecified it is difficult to use this function in a portable way. date_and_time() can be used to decompose the return value of system_clock() into year, month, day, hour, minute, and second.

GNU Fortran provides functions similar to functions in the C standard library.


Sys.time() returns a value of type POSIXct.

date/time type

The data type used to hold a combined date and time value.

date/time difference type

The data type used to hold the difference between two date/time types.

get date parts

How to get the year, the month as an integer from 1 through 12, and the day of the month from a date/time value.


ltime() gets the parts that correspond to the local time zone. gmtime() can be used to get the parts that correspond to the UTC time zone.

get time parts

How to get the hour as an integer from 0 through 23, the minute, and the second from a date/time value.


ltime() gets the parts that correspond to the local time zone. gmtime() can be used to get the parts that correspond to the UTC time zone.

build date/time from parts

How to build a date/time value from the year, month, day, hour, minute, and second as integers.

convert to string

How to convert a date value to a string using the default format for the locale.


How to parse a date/time value from a string in the manner of strptime from the C standard library.


How to write a date/time value to a string in the manner of strftime from the C standard library.

Multidimensional Array Footnotes

Arrays map integers to arbitrary values. The arrays supported by the languages in this reference sheet are homogeneous, which means that the values in the codomain of the array must all be of the same type.

The languages in this sheet all support multidimensional arrays. A multidimensional array maps tuples of integers to values. All tuples which can be used as indices in a multidimensional array are of the same length and this length is the dimension of the array.

Arrays use contiguous regions of memory to store their values. Thus, an array with an element at index 1 and index 10 must allocate space for elements at indices 2 through 9, even if values are not explicitly set or needed. The shape of a multidimensional array can be expressed by a tuple of positive integers with the same length as the dimension of the array.

Arrays provide constant time access when looking up values by their indices.

A vector is a one dimensional array which supports these operations:

  • addition on vectors of the same length
  • scalar multiplication
  • a dot product
  • a norm

The languages in this reference sheet provide the above operations for all one dimensional arrays which contain numeric values.

NumPy adds the homogeneous ndarray type to the native Python list. A Python list is nonhomogeneous and one dimensional, but because they can contain lists as values they can be used to hold multidimensional data. Python lists are described in the Python reference sheet.

array literal


An array in Octave is in fact a 1 x n matrix.


c(1,2,3) is a vector and array(c(1,2,3)) is a one dimensional array. The documentation says that some functions may treat the two objects differently. In the absence of knowing what those differences are it seems best to use the vector.

2d array literal

3d array literal

must arrays be homogeneous

Can an array be created with elements of different type?


The array literal


will create an array with 5 elements of class char.


The array literal


will create an array of 3 elements of class character, which is the R string type.

array data types

What data types are permitted in arrays.


Arrays in Octave can only contain numeric elements. This follows from the fact that Octave "arrays" are in fact 1 x n matrices.

Array literals can have a nested structure, but Octave will flatten them. The following literals create the same array:

[ 1 2 3 [ 4 5 6] ]
[ 1 2 3 4 5 6 ]

Logical values can be put into an array because true and false are synonyms for 1 and 0. Thus the following literals create the same arrays:

[ true false false ]
[ 1 0 0 ]

If a string is encountered in an array literal, the string is treated as an array of ASCII values and it is concatenated with other ASCII values to produce as string. The following literals all create the same string:

[ 'foo', 98, 97, 114]
[ 'foo', 'bar' ]

If the other numeric values in an array literal that includes a string are not integer values that fit into a ASCII byte, then they are converted to byte sized values.


Array literals can have a nested structure, but R will flatten them. The following literals produce the same array of 6 elements:


If an array literal contains a mixture of booleans and numbers, then the boolean literals will be converted to 1 (for TRUE and T) and 0 (for FALSE and F).

If an array literal contains strings and either booleans or numbers, then the booleans and numbers will be converted to their string representations. For the booleans the string representations are "TRUE'" and "FALSE".

array element access

index of array element

array length

array concatenation




Tuple, Dictionary, and Sequence Footnotes

homogeneous array vector tuple record map
NumPy list vector tuple dict dict
Octave rank 1 matrix rank 1 matrix cell array struct
R vector vector list list

tuple literal

How to create a tuple, which we define as a fixed length, inhomogeneous list.

tuple element access

How to access an element of a tuple.

tuple length

How to get the number of elements in a tuple.

dictionary literal

The syntax for a dictionary literal.

dictionary lookup

How to use a key to lookup a value in a dictionary.


Function Foontotes



function value

Execution Control Footnotes


How to write a branch statement.


How to write a conditional loop.


How to write a C-style for statement.


How to break out of a loop. How to jump to the next iteration of a loop.


Fortran has a continue statement which is a no-op statement used as a target for goto statements.

Here is an example of using exit to terminate what would otherwise be an infinite loop:

n = 1
   if (n > 10) exit
   write(*, *) n
   n = n + 1
end do

Labels can be provided for nested do loops. The labels can be provided as arguments to exit and cycle:

  foo: do
     bar: do n = 1, 10, 1
        write(*,*) n
        exit foo
     end do bar
  end do foo

raise exception

How to raise an exception.

handle exception

How to handle an exception.

finally block

How to write code that executes even if an exception is raised.

Environment and I/O Foontotes

Library and Module Footnotes

load library

How to load a library.

list loaded libraries

Show the list of libraries which have been loaded.

library search path

The list of directories the interpreter will search looking for a library to load.

source file

How to source a file.


When sourcing a file, the suffix if any must be specified, unlike when loading library. Also, a library may contain a shared object, but a sourced file must consist of just R source code.

install package

How to install a package.

list installed packages

How to list the packages which have been installed.

Reflection Footnotes

data type

How to get the data type of a value.


How to get the attributes for an object.


How to get the methods for an object.

variables in scope

How to list the variables in scope.

undefine variable

How to undefine a variable.


How to interpret a string as source code and execute it.

function documentation

How to get the documentation for a function.

list library functions

How to list the functions and other definitions in a library.

search documentation

How to search the documentation by keyword.

Vector Footnotes

vector literal

element-wise arithmetic operators

scalar multiplication

dot product

cross product



The norm function returns the p-norm, where the second argument is p. If no second argument is provided, the 2-norm is returned.

Matrix Footnotes

literal or constructor

Literal syntax or constructor for creating a matrix.

The elements of a matrix must be specified in a linear order. If the elements of each row of the matrix are adjacent to other elements of the same row in the linear order we say the order is row contiguous. If the elements of each column are adjacent to other elements of the same column we say the order is column contiguous.


Square brackets are used for matrix literals. Semicolons are used to separate rows, and commas separate row elements. Optionally, newlines can be used to separate rows and whitespace to separate row elements.


Matrices are created by passing a vector containing all of the elements, as well as the number of rows and columns, to the matrix constructor.

If there are not enough elements in the data vector, the values will be recycled. If there are too many extra values will be ignored. However, the number of elements in the data vector must be a factor or a multiple of the number of elements in the final matrix or an error results.

When consuming the elements in the data vector, R will normally fill by column. To change this behavior pass a byrow=T argument to the matrix constructor:

A = matrix(c(1,2,3,4),nrow=2,byrow=T)


How to get the dimensions of a matrix.

element access

How to access an element of a matrix. All languages described here follow the convention from mathematics of specifying the row index before the column index.


Rows and columns are indexed from one.


Rows and columns are indexed from one.

row access

How to access a row.

column access

How to access a column.

submatrix access

How to access a submatrix.

scalar multiplication

How to multiply a matrix by a scalar.

element-wise operators

Operators which act on two identically sized matrices element by element. Note that element-wise multiplication of two matrices is used less frequently in mathematics than matrix multiplication.

from numpy import array
matrix(array(A) * array(B))
matrix(array(A) / array(B))


How to multiply matrices. Matrix multiplication should not be confused with element-wise multiplication of matrices. Matrix multiplication in non-commutative and only requires that the number of columns of the matrix on the left match the number of rows of the matrix. Element-wise multiplication, by contrast, is commutative and requires that the dimensions of the two matrices be equal.

kronecker product

The Kronecker product is a non-commutative operation defined on any two matrices. If A is m x n and B is p x q, then the Kronecker product is a matrix with dimensions mp x nq.


How to test two matrices for equality.


== and != perform entry-wise comparison. The result of using either operator on two matrices is a matrix of boolean values.

~= is a synonym for !=.


== and != perform entry-wise comparison. The result of using either operator on two matrices is a matrix of boolean values.


How to compute the 1-norm, the 2-norm, the infinity norm, and the frobenius norm.


norm(A) is the same as norm(A,2).

Statistics Footnotes

A statistic is a single number which summarizes a population of data. The most familiar example is the mean or average. Statistics defined for discrete populations can often be meaningfully extended to continuous distributions by replacing summations with integration.

An important class of statistics are the nth moments. The nth moment $\mu'_n$ of a population of k values xi with mean μ is:

\begin{align} \mu'_n = \sum_{i=1}^k x_i^n \end{align}

The nth central moment μn of the same population is:

\begin{align} \mu_n = \sum_{i=1}^k (x_i - \mu)^n \end{align}

first moment statistics

The sum and the mean.

The mean is the first moment. It is one definition of the center of the population. The median and the mode are also used to define the center. In most populations they will be close to but not identical to the mean.

second moment statistics

The variance and the standard deviation. The variance is the second central moment. It is a measure of the spread or width of the population.

The standard deviation is the square root of the variance. It is also a measurement of population spread. The standard deviation has the same units of measurement as the data in the population.

second moment statistics for samples

The sample variance and sample standard deviation.


The skewness of a population.

The skewness measures the asymmetrically of the population. The skewness will be negative, positive, or zero when the population is more spread out on the left, more spread out on the right, or similarly spread out on both sides, respectively.

The skewness can be calculated from the third moment and the standard deviation:

\begin{align} \gamma_1 = E\Big[\Big(\frac{x - \mu}{\sigma}\Big)^3\Big] = \frac{\mu_3}{\sigma^3} \end{align}

When estimating the population skewness from a sample a correction factor is often used, yielding the sample skewness:

\begin{align} \frac{(n(n-1))^{\frac{1}{2}}}{n-2} \gamma_1 \end{align}

octave and matlab:

Octave uses the sample standard deviation to compute skewness. This behavior is different from Matlab and should possibly be regarded as a bug.

Matlab, but not Octave, will take a flag as a second parameter. When set to zero Matlab returns the sample skewness:

skewness(x, 0)


Set the named parameter bias to False to get the sample skewness:

stats.skew(x, bias=False)


The kurtosis of a population.

The formula for kurtosis is:

\begin{align} \gamma_2 = \frac{\mu_4}{\sigma^4} - 3 \end{align}

When kurtosis is negative the sides of a distribution tend to be more convex than when the kurtosis is is positive. A negative kurtosis distribution tends to have a wide, flat peak and narrow tails. Such a distribution is called platykurtic. A positive kurtosis distribution tends to have a narrow, sharp peak and long tails. Such a distribution is called leptokurtic.

The fourth standardized moment is

\begin{align} \beta_2 = \frac{\mu_4}{\sigma^4} \end{align}

The fourth standardized moment is sometimes taken as the definition of kurtosis in older literature. The reason the modern definition is preferred is because it assigns the normal distribution a kurtosis of zero.


Octave uses the sample standard deviation when computing kurtosis. This should probably be regarded as a bug.


R uses the older fourth standardized moment definition of kurtosis.

nth moment and nth central moment

How to compute the nth moment (also called the nth absolute moment) and the nth central moment for arbitrary n.


The mode is the most common value in the sample.

The mode is a measure of central tendency like the mean and the median. A problem with the mean is that it can produce values not found in the data. For example the mean number of persons in an American household was 2.6 in 2009.

The mode might not be unique. If there are two modes the sample is said to be bimodal, and in general if there is more than one mode the sample is said to be multimodal.

quantile statistics

If the data is sorted from smallest to largest, the minimum is the first value, the median is the middle value, and the maximum is the last value. If there are an even number of data points, the median is the average of the middle two points.

The median divides the population into two halves. When the population is divided into four parts the division markers are called the first, second, and third quartile. When the population is divided into a hundred the division markers are called percentiles. If the population is divided into nparts the markers are called the 1st, 2nd, …, (n-1)th n-quantile.

linear regression y = ax + b

How to get the slope a and intercept b for a line which best approximates the data. How to get the residuals.

If there are more than two data points, then the system is overdetermined and in general there is no solution for the slope and the intercept. Linear regression looks for line that fits the points as best as possible. The least squares solution is the line that minimizes the sum of the square of the distances of the points from the line.

The residuals are the difference between the actual values of y and the calculated values using ax + b. The norm of the residuals can be used as a measure of the goodness of fit.

bivariate statistics

The correlation and the covariance.

The correlation is a number from -1 to 1. It is a measure of the linearity of the data, with values of -1 and 1 representing indicating a perfectly linear relationship. When the correlation is positive the quantities tend to increase together and when the correlation is negative one quantity will tend to increase as the other decreases.

A variable can be completely dependent on another and yet the two variables can have zero correlation. This happens for Y = X2 where uniform X on the interval [-1, 1]. Anscombe's quartet gives four examples of data sets each with the same fairly high correlation 0.816 and yet which show significant qualitative differences when plotted.

The covariance is defined by

\begin{align} E[X -\mu_X)(Y- \mu_Y)] \end{align}

The correlation is the normalized version of the covariance. It is defined by

\begin{align} \frac{E[X -\mu_X)(Y- \mu_Y)]}{\sigma_X \sigma_Y} \end{align}

Distribution Footnotes

A distribution density function f(x) is a non-negative function which, when integrated over its entire domain is equal to one. The distributions described in this sheet have as their domain the real numbers. The support of a distribution is the part of the domain on which the density function is non-zero.

A distribution density function can be used to describe the values one is likely to see when drawing an example from a population. Values in areas where the density function is large are more likely than values in areas where the density function is small. Values where there density function is zero do not occur. Thus it can be useful to plot the density function.

To derive probabilities from a density function one must integrate or use the associated cumulative density function

\begin{align} F(x) = \int_{-\infty}^x f(t) dt \end{align}

which gives the probability of seeing a value less than or equal to x. As probabilities are non-negative and no greater than one, F is a function from (-, ) to [0,1]. The inverse of F is called the inverse cumulative distribution function or the quantile function for the distribution.

For each distribution statistical software will generally provide four functions: the density, the cumulative distribution, the quantile, and a function which returns random numbers in frequencies that match the distribution. If the software does not provide a random number generating function for the distribution, the quantile function can be composed with the built-in random number generator that most languages have as long as it returns uniformly distributed floats from the interval [0, 1].

probability density
probability mass
cumulative density
cumulative distribution
inverse cumulative density
inverse cumulative distribution
percent point
random variate

Discrete distributions such as the binomial and the poisson do not have density functions in the normal sense. Instead they have probability mass functions which assign probabilities which sum up to one to the integers. In R warnings will be given if non integer values are provided to the mass functions dbinom and dpoiss.

The cumulative distribution function of a discrete distribution can still be defined on the reals. Such a function is constant except at the integers where it may have jump discontinuities.

Most well known distributions are in fact parametrized families of distributions. The following table lists some of them with their parameters and properties:

distribution parameters support density f(x) mean variance excel function
binomial B(n,p) {0,1,…,n} $\frac{n!}{x!(n-x)!} p^x(1-p)^{n-x}$ np np(1-p) BINOMDIST(x,n,p,FALSE)
BINOM.INV(n, p, α)
poisson Pois(λ) {0,1,2,…} $\frac{\mu^x e^{-\mu}}{x!}$ λ λ POISSON(x, λ, FALSE)
normal N(μ, σ) (-,) $\frac{1}{\sqrt{2\pi \sigma}} e^{-\frac{(x-\mu)^2}{2\sigma^2}}$ μ σ2 NORMDIST(x, μ, σ, FALSE)
NORMINV(α, μ, σ)
gamma Γ(k, θ) [0,) $x^{k-1}\frac{exp(\frac{-x}{\theta})}{\Gamma(k) \theta^k}$ kθ kθ2 GAMMADIST(x, k, θ, FALSE)
GAMMAINV(α, k, θ)
exponential Exp(λ) [0, ) $\lambda e^{-\lambda x}$ λ-1 λ-2 EXPON.DIST(x, λ, FALSE)
GAMMAINV(y, 1, 1/λ)
GAMMAINV(RAND(), 1, 1/λ)
chi-squared Χ2(ν) [0, ) $\frac{1}{2^{k/2}\Gamma(k/2)} x^{k/2 - 1} e^{-x/2}$ ν 2ν CHISQ.DIST(x, ν, FALSE)
beta Be(α, β) [0, 1] $\frac{x^{\alpha-1}(1-x)^{\beta-1}}{B(\alpha, \beta)}$ $\frac{\alpha}{\alpha + \beta}$ $\frac{\alpha\beta}{(\alpha+\beta)^2(\alpha+\beta+1)}$ BETADIST(x, α, β, FALSE)
BETAINV(p, α, β)
uniform U(a, b) [a, b] $\frac{1}{b-a}$ $\frac{a+b}{2}$ $\frac{(b-a)^2}{12}$ 1/(b-a)
α * (b-a) + a
RAND()*(b-a) + a
Student's t t(ν) (-,) $\frac{\Gamma(\frac{\nu+1}{2})}{\sqrt{\nu \pi} \Gamma(\frac{\nu}{2})} (1 + \frac{x^2}{\nu})^{-\frac{\nu+1}{2}}$ $\begin{cases} 0 & \nu > 1 \\ \text{undefined} & \text{otherwise} \end{cases}$ $\begin{cases} \frac{\nu}{\nu - 2} & \nu > 2 \\ \infty & 1 < \nu \le 2 \\ \text{undefined} & \text{otherwise} \end{cases}$ T.DIST(x, ν, FALSE)
T.DIST(x, ν, TRUE)
T.INV(α, ν)
T.INV(RAND(), ν)
Snedecor's F F(d1, d2) [0, ) $\frac{\sqrt{\frac{(d_1 x)^{d_1} d_2^{d_2}}{(d_1 x + d_2)^{d_1+d_2}}}}{x B(d_1, d_2)}$ $\frac{d_2}{d_2 - 2}$ for d2 > 2 F.DIST(x, d1, d2, FALSE)
F.DIST(x, d1, d2, TRUE)
F.INV(α, d1, d2)
F.INV(RAND(), d1, d2)
________ _____________________

The information entropy of a continuous distribution with density f(x) is defined as:

\begin{align} -\int_\mathbb{R} f(x) \; \log(f(x)) \; dx \end{align}

In Bayesian analysis the distribution with the greatest entropy, subject to the known facts about the distribution, is called the maximum entropy probability distribution. It is considered the best distribution for modeling the current state of knowledge.


The probability mass, cumulative distribution, quantile, and random number generating functions for the binomial distribution.

The binomial distribution is a discrete distribution. It models the number of successful trails when n is the number of trials and p is the chance of success for each trial. An example is the number of heads when flipping a coin 100 times. If the coin is fair then p is 0.50.


Random numbers in a binomial distribution can also be generated with:

np.random.binomial(n, p)


The probability mass, cumulative distribution, quantile, and random number generating functions for the binomial distribution.

The poisson distribution is a discrete distribution. It is described by a parameter lam which is the mean value for the distribution. The poisson distribution is used to model events which happen at a specified average rate and independently of each other. Under these circumstances the time between successive events will be described by an exponential distribution and the events are said to be described by a poisson process.


Random numbers in a poisson distribution can also be generated with:

np.random.poisson(lam, size=1)


The probability density, cumulative distribution, quantile, and random number generating functions for the uniform distribution.

The parameters are the mean μ and the standard deviation σ. The standard normal distribution has μ of 0 and σ of 1.

The normal distribution is the maximum entropy distribution for a given mean and variance. According to the central limit theorem, if {X1, …, Xn} are any independent and identically distributed random variables with mean μ and variance σ2, then Sn := Σ Xi / n converges to a normal distribution with mean μ and variance σ2/n.


Random numbers in a normal distribution can also be generated with:



The probability density, cumulative distribution, quantile, and random number generating functions for the gamma distribution.

The parameter k is called the shape parameter and θ is called the scale parameter. The rate of the distribution is β = 1/θ.

If Xi are n independent random variables with Γ(ki, θ) distribution, then Σ Xi has distribution Γ(Σ ki, θ).

If X has Γ(k, θ) distribution, then αX has Γ(k, αθ) distribution.


The probability density, cumulative distribution, quantile, and random number generating functions for the exponential distribution.


The probability density, cumulative distribution, quantile, and random number generating functions for the chi-squared distribution.


The probability density, cumulative distribution, quantile, and random number generating functions for the beta distribution.


The probability density, cumulative distribution, quantile, and random number generating functions for the uniform distribution.

The uniform distribution is described by the parameters a and b which delimit the interval on which the density function is nonzero.

The uniform distribution is maximum entropy probability distribution with support [a, b].

Consider the uniform distribution on [0, b]. Suppose that we take k samples from it, and m is the largest of the samples. The minimum variance unbiased estimator for b is

\begin{align} \frac{k+1}{k}m \end{align}

octave, r, numpy:

a and b are optional parameters and default to 0 and 1 respectively.

Student's t

The probability density, cumulative distribution, quantile, and random number generating functions for Student's t distribution.

Snedecor's F

The probability density, cumulative distribution, quantile, and random number generating functions for Snedecor's F distribution.

Data Set Footnotes

A data set is essentially an in memory database table. Data sets are called data frames in R. Pandas is a Python library which implements a data set.

construct from arrays

How to construct a data set from a set of arrays representing the columns.

view in spreadsheet

How to view and edit the data set in a spreadsheet.

list column names

How to show the names of the columns.

attach column names

How to make column name a variable in the current scope which refers to the column as an array.


Each column of the data set is copies into a variable named after the column containing the column as a vector. Modifying the data in the variable does not alter the original data set.

detach column names

How to remove attached column names from the current scope.

column access

How to access a column in a data set.

row access

How to access a row in a data set.


people[1,] returns the 1st row from the data set people as a new data set with one row. This can be converted to a list using the function as.list. There is often no need because lists and one row data sets have nearly the same behavior.

access sub data set

How to select a subset of the rows and a subset of the columns.

access datum

How to access a single datum in a data set; i.e. the value in a column of a single row.

sort rows of data set

How to sort the rows in a data set according to the values in a specified column.

sort rows of data set

How to sort the rows in descending order according to the values in a specified column.

map data set

How to apply a mapping transformation to the rows of a data set.

filter data set

How to select the rows of a data set that satisfy a predicate.

load from csv

Load a data set from a CSV file.

save as csv

Save a data set to a CSV file.

show built-in data sets

Show the built-in data sets.

load built-in data set

Load one of the built-in data sets.

Univariate Chart Footnotes

A univariate chart can be used to display a list or array of numerical values. Univariate data can be displayed in a table with a single column or two columns if each numerical value is given a name. A multivariate chart, by contrast, is used to display a list or array of tuples of numerical values.

In order for a list of numerical values to be meaningfully displayed in a univariate chart, it must be meaningful to perform comparisons (<, >, =) on the values. Hence the values should have the same unit of measurement.

vertical bar chart

A chart which represents values with rectangular bars which line up on the bottom. It is a deceptive practice for the bottom not to represent zero, even if a y-axis with labelled tick marks or grid lines is provided. A cut in the vertical axis and one of the bars may be desirable if the cut value is a large outlier. Putting such a cut all of the bars near the bottom is a deceptive practice similar not taking to the base of the bars to be zero, however.

Another bad practice is the 3D bar chart. In such a chart heights are represented by the height of what appear to be three dimensional blocks. Such charts impress an undiscriminating audience but make it more difficult to make a visual comparison of the charted quantities.

horizontal bar chart

A bar chart in which zero is the y-axis and the bars extend to the right.

pie chart

A bar chart displays values using the areas of circular sectors or equivalently, the lengths of the arcs of those sectors. A pie chart implies that the values are percentages of a whole. The viewer is likely to make an assumption about what the whole circle represents. Thus, using a pie chart to show the revenue of some companies in a line of business could be regarded as deceptive if there are other companies in the same line of business which are left out. The viewer may mistakenly assume the whole circle represents the total market.

If two values are close in value, people cannot determine visually which of the corresponding sectors in a pie chart is larger without the aid of a protractor. For this reason many consider bar charts superior to pie charts.

Many software packages make 3D versions of pie charts which communicate no additional information and in fact make it harder to interpret the data.

stacked dot chart

A chart which communicates values by means of stacks of dots. A dot chart is equivalent to a bar chart but emphasizes that the quantities are small, integral values.

There is a single dot variation of the dot chart in which only the topmost dot is drawn. The single dot variation will draw the dot on a line; it doesn't imply that the represented quantity is an integer.

stem-and-leaf plot


box-and-whisker plot

set chart title

Bivariate Chart Footnotes

stacked bar chart

Trivariate Chart Footnotes


The GNU Fortran Compiler
Fortran 77 Tutorial
Fortran 90 Tutorial
Fortran Standards Documents
BLAS: A Quick Reference Guide (pdf)

Modern Fortran compilers support two source code formats: the traditional fixed format and the free format introduced with Fortran 90.

If a Fortran source file has a .f suffix, the gfortran compiler expects the code to have fixed format. If the suffix is .f90 or .f95 it expects free format code. Emacs is also suffix aware and provides fortran-mode and f90-mode for fixed format and free format code respectively.

Here is an example of fixed format code:

C Hello World
* in Fortran 77

      program hello
10000 write(*,*) 'Hello,'
     + , ' World!'
      end program hello

This first column can contain a 'C', 'c', or '*' to indicate the line is a comment.

Columns 1 through 5 can contain an optional statement label. A statement label consists of digits. The statement label may contain leading zeros which are ignored. A statement label cannot consist entirely of zeros.

If column 6 contains a non-space character and columns 1 through 5 are blank, then the line is treated as a continuation of the previous line. The continuation character is not itself part of the statement, so any non-space character can be used, but '+' is a common choice.

Columns 7 through 72 contain the statement.

Columns 73 through 80 can contain optional sequence numbers. They were formerly used to help keep punch cards in the correct order.

Here is an example of free format code:

! Hello World in Fortran 90

program hello
  write(*,*) 'Hello,' &
       , ' World!'
end program hello

There are no special columns in free format code. There is no limit on the length of lines or statements. If it is desirable to split a statement up over multiple lines, the '&' character can be used to indicate the statement continues on the following line.


Octave Manual
MATLAB Documentation
gnuplot Documentation
Differences between Octave and MATLAB
Octave-Forge Packages

The basic data type of MATLAB is a matrix of floats. There is no distinction between a scalar and a 1x1 matrix, and functions that work on scalars typically work on matrices as well by performing the scalar function on each entry in the matrix and returning the resultings in a matrix with the same dimensions. Operators such as the logical operators ('&' '|' '!'), comparison operators ('==', '!=', '<', '>'), and arithmetic operators ('+', '-') all work this way. However the multiplication '*' and division '/' operators perform matrix multiplication and matrix division, respectively. The '.*' and '.*' operators are available if entry-wise multiplication or division is desired.

Floats are by default double precision; single precision can be specified with the single constructor. MATLAB has convenient matrix literal notation: commas or spaces can be used to separate row entries, and semicolons or newlines can be used to separate rows.

Arrays and vectors are implemented as single-row (1xn) matrices. As a result an n-element vector must be transposed before it can be multiplied on the right of a mxn matrix.

Numeric literals that lack a decimal point such as 17 and -34 create floats, in contrast to most other programming languages. To create an integer, an integer constructor which specifies the size such as int8 and uint16 must be used. Matrices of integers are supported, but the entries in a given matrix must all have the same numeric type.

Strings are implemented as single-row (1xn) matrices of characters, and as a result matrices cannot contain strings. If a string is put in matrix literal, each character in the string becomes an entry in the resulting matrix. This is consistent with how matrices are treated if they are nested inside another matrix. The following literals all yield the same string or 1xn matrix of characters:

[ 'f' 'o' 'o' ]
[ 'foo' ]
[ [ 'f' 'o' 'o' ] ]

true and false are functions which return matrices of ones and zeros. The ones and zeros have type logical instead of double, which is created by the literals 1 and 0. Other than having a different class, the 0 and 1 of type logical behave the same as the 0 and 1 of type double.

MATLAB has a tuple type (in MATLAB terminology, a cell array) which can be used to hold multiple strings. It can also hold values with different types.

Octave is a free, open source application for floating point and matrix computations which can interface with numerical routines implemented in C or Fortran. Octave implements the core MATLAB language, and as a result MATLAB scripts will usually run under Octave. Octave scripts are less likely to run under MATLAB because of extensions which Octave is made to the core language.. Octave's plotting functions use gnuplot.


An Introduction to R
The Comprehensive R Archive Network

R is an application for statistical analysis. It is a free, open source implementation of the S programming language developed at Bell Labs.

The basic data types of R are vectors of floats, vectors of strings, and vectors of booleans. There is no distinction between a scalar and a vector with one entry in it, and functions and operators which accept a scalar argument will typically accept a vector argument, returning a vector of the same size with the scalar operation performed on each the entries of the original vector.

The scalars in a vector must all be of the same type, but R also provides a list data type which can be used as a tuple (entries accessed by index) or a record (entries accessed by name).

In addition R provides a data frame type which is a list (in R terminology) of vectors all of the same length. Data frames are equivalent to the data sets of other statistical analysis packages.


NumPy and SciPy Documentation
matplotlib intro
NumPy for Matlab Users


Fortran History

The initial Fortran compiler was released for the IBM 704 in 1957. It was followed by the Fortran II compiler in 1958 which added support for user defined functions and subroutines.

In 1962 IBM released Fortran IV, which was tweaked to make it easier to write portable programs. IBM released Fortran IV compilers for the IBM 7090, 7094, and IBM's first supercomputer, the 7030. Fortrran IV became an ANSI in 1966.

In 1977 the Fortran standard was updated to add block IF statements and the CHARACTER data type. Before the CHARACTER data type, string data was handled using Hollerith constants. An example of a Hollerith constant for 'ABC' is 3HABC. The three indicates the number of characters. The largest number that could be used in a Hollerith constant depended upon the machine architecture and in particular how many characters could be stored in an integer data type.

In 1990 the Fortran standard was updated, adding free format text for source code as an option to the traditional fixed format. The fixed format is a relic from when programs were entered by punching them into punch cards.

MATLAB History


In the 1970s the Argonne National Laboratory wrote some high quality Fortran libraries for matrix computations, starting with EISPACK in 1973. Cleve Moler, a professor at the University of New Mexico, developed the scripting language MATLAB (Matrix Laboratory) in the late 1970s so that students could use these libraries without knowing Fortran. MATLAB was initially free, but it was reimplemented in C and released as a commercial product in 1984.

Version 1.0 of Octave was release in 1994 under the GNU license.

R History

A Brief History of S Becker 1994

S, a language for doing work in statistics, was developed by John Chambers and others at Bell Labs in 1976. Originally it ran on the GCOS operating system. It was ported to Unix in 1979, and distributed outside of Bell Labs with source in 1981. SAS, by comparison, was initially released in 1971 for IBM mainframes, and was ported to other systems such as VMS in the early 1980s. Both S and SAS were initially implemented in Fortran. The source code for S in particular was run through the M4 and then the Ratfor preprocessors before compilation by the Fortran compiler.

The S language was revised in 1988. Functions were added to the language, which previously only had macros. The functions could be stored in variables and higher order functions such as apply were added. Data frames were also added and multiple dispatch was implemented for the print function.

R is a GNU version of S. The first stable production version was released in 2000.

NumPy History

Numeric was the predecessor of NumPy. It appeared in 1995. Several libraries written on top of Numeric merged to become SciPy in 2001.

In 2005 the code for Numeric was refactored to make it more maintainable, in the hope of eventually getting it into the Python standard library. It was renamed NumPy. It incorporated some of the features from a competing package called numarray.

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License