# MATLAB - Python - Julia cheatsheet

## Dependencies and Setup¶

MATLAB code assumes you you are using MATLAB 2019a or later.

Python code assumes you have run import numpy as np

Julia code assumes you are using v1.0.2+, Compat v1.3.0+, and have run using LinearAlgebra, Statistics, Compat

## Creating Vectors¶

Operation

MATLAB

Python

Julia

Row vector: size (1, n)

A = [1 2 3]

A = np.array([1, 2, 3]).reshape(1, 3)

A = [1 2 3]


Column vector: size (n, 1)

A = [1; 2; 3]

A = np.array([1, 2, 3]).reshape(3, 1)

A = [1 2 3]'


1d array: size (n, )

Not possible

A = np.array([1, 2, 3])

A = [1; 2; 3]


or

A = [1, 2, 3]


Integers from j to n with step size k

A = j:k:n

A = np.arange(j, n+1, k)

A = j:k:n


Linearly spaced vector of k points

A = linspace(1, 5, k)

A = np.linspace(1, 5, k)

A = range(1, 5,
length = k)


## Creating Matrices¶

Operation

MATLAB

Python

Julia

Create a matrix

A = [1 2; 3 4]

A = np.array([[1, 2], [3, 4]])

A = [1 2; 3 4]


2 x 2 matrix of zeros

A = zeros(2, 2)

A = np.zeros((2, 2))

A = zeros(2, 2)


2 x 2 matrix of ones

A = ones(2, 2)

A = np.ones((2, 2))

A = ones(2, 2)


2 x 2 identity matrix

A = eye(2, 2)

A = np.eye(2)

A = I # will adopt
# 2x2 dims if demanded by
# neighboring matrices


Diagonal matrix

A = diag([1 2 3])

A = np.diag([1, 2, 3])

A = Diagonal([1, 2,
3])


Uniform random numbers

A = rand(2, 2)

A = np.random.rand(2, 2)

A = rand(2, 2)


Normal random numbers

A = randn(2, 2)

A = np.random.randn(2, 2)

A = randn(2, 2)


Sparse Matrices

A = sparse(2, 2)
A(1, 2) = 4
A(2, 2) = 1

from scipy.sparse import coo_matrix

A = coo_matrix(([4, 1],
([0, 1], [1, 1])),
shape=(2, 2))

using SparseArrays
A = spzeros(2, 2)
A[1, 2] = 4
A[2, 2] = 1


Tridiagonal Matrices

A = [1 2 3 NaN;
4 5 6 7;
NaN 8 9 0]
spdiags(A',[-1 0 1], 4, 4)

import sp.sparse as sp
diagonals = [[4, 5, 6, 7], [1, 2, 3], [8, 9, 10]]
sp.diags(diagonals, [0, -1, 2]).toarray()

x = [1, 2, 3]
y = [4, 5, 6, 7]
z = [8, 9, 10]
Tridiagonal(x, y, z)


## Manipulating Vectors and Matrices¶

Operation

MATLAB

Python

Julia

Transpose

A.'

A.T

transpose(A)


A'

A.conj()

A'


Concatenate horizontally

A = [[1 2] [1 2]]


or

A = horzcat([1 2], [1 2])

B = np.array([1, 2])
A = np.hstack((B, B))

A = [[1 2] [1 2]]


or

A = hcat([1 2], [1 2])


Concatenate vertically

A = [[1 2]; [1 2]]


or

A = vertcat([1 2], [1 2])

B = np.array([1, 2])
A = np.vstack((B, B))

A = [[1 2]; [1 2]]


or

A = vcat([1 2], [1 2])


Reshape (to 5 rows, 2 columns)

A = reshape(1:10, 5, 2)

A = A.reshape(5, 2)

A = reshape(1:10, 5, 2)


Convert matrix to vector

A(:)

A = A.flatten()

A[:]


Flip left/right

fliplr(A)

np.fliplr(A)

reverse(A, dims = 2)


Flip up/down

flipud(A)

np.flipud(A)

reverse(A, dims = 1)


Repeat matrix (3 times in the row dimension, 4 times in the column dimension)

repmat(A, 3, 4)

np.tile(A, (4, 3))

repeat(A, 3, 4)


Preallocating/Similar

x = rand(10)
y = zeros(size(x, 1), size(x, 2))


N/A similar type

x = np.random.rand(3, 3)
y = np.empty_like(x)

# new dims
y = np.empty((2, 3))

x = rand(3, 3)
y = similar(x)
# new dims
y = similar(x, 2, 2)


Broadcast a function over a collection/matrix/vector

f = @(x) x.^2
g = @(x, y) x + 2 + y.^2
x = 1:10
y = 2:11
f(x)
g(x, y)


def f(x):
return x**2
def g(x, y):
return x + 2 + y**2
x = np.arange(1, 10, 1)
y = np.arange(2, 11, 1)
f(x)
g(x, y)


f(x) = x^2
g(x, y) = x + 2 + y^2
x = 1:10
y = 2:11
f.(x)
g.(x, y)


## Accessing Vector/Matrix Elements¶

Operation

MATLAB

Python

Julia

Access one element

A(2, 2)

A[1, 1]

A[2, 2]


Access specific rows

A(1:4, :)

A[0:4, :]

A[1:4, :]


Access specific columns

A(:, 1:4)

A[:, 0:4]

A[:, 1:4]


Remove a row

A([1 2 4], :)

A[[0, 1, 3], :]

A[[1, 2, 4], :]


Diagonals of matrix

diag(A)

np.diag(A)

diag(A)


Get dimensions of matrix

[nrow ncol] = size(A)

nrow, ncol = np.shape(A)

nrow, ncol = size(A)


## Mathematical Operations¶

Operation

MATLAB

Python

Julia

Dot product

dot(A, B)

np.dot(A, B) or A @ B

dot(A, B)

A ⋅ B # \cdot<TAB>


Matrix multiplication

A * B

A @ B

A * B


Inplace matrix multiplication

Not possible

x = np.array([1, 2]).reshape(2, 1)
A = np.array(([1, 2], [3, 4]))
y = np.empty_like(x)
np.matmul(A, x, y)

x = [1, 2]
A = [1 2; 3 4]
y = similar(x)
mul!(y, A, x)


Element-wise multiplication

A .* B

A * B

A .* B


Matrix to a power

A^2

np.linalg.matrix_power(A, 2)

A^2


Matrix to a power, elementwise

A.^2

A**2

A.^2


Inverse

inv(A)


or

A^(-1)

np.linalg.inv(A)

inv(A)


or

A^(-1)


Determinant

det(A)

np.linalg.det(A)

det(A)


Eigenvalues and eigenvectors

[vec, val] = eig(A)

val, vec = np.linalg.eig(A)

val, vec = eigen(A)


Euclidean norm

norm(A)

np.linalg.norm(A)

norm(A)


Solve linear system $Ax=b$$Ax=b$ (when $A$$A$ is square)

A\b

np.linalg.solve(A, b)

A\b


Solve least squares problem $Ax=b$$Ax=b$ (when $A$$A$ is rectangular)

A\b

np.linalg.lstsq(A, b)

A\b


## Sum / max / min¶

Operation

MATLAB

Python

Julia

Sum / max / min of each column

sum(A, 1)
max(A, [], 1)
min(A, [], 1)

sum(A, 0)
np.amax(A, 0)
np.amin(A, 0)

sum(A, dims = 1)
maximum(A, dims = 1)
minimum(A, dims = 1)


Sum / max / min of each row

sum(A, 2)
max(A, [], 2)
min(A, [], 2)

sum(A, 1)
np.amax(A, 1)
np.amin(A, 1)

sum(A, dims = 2)
maximum(A, dims = 2)
minimum(A, dims = 2)


Sum / max / min of entire matrix

sum(A(:))
max(A(:))
min(A(:))

np.sum(A)
np.amax(A)
np.amin(A)

sum(A)
maximum(A)
minimum(A)


Cumulative sum / max / min by row

cumsum(A, 1)
cummax(A, 1)
cummin(A, 1)

np.cumsum(A, 0)
np.maximum.accumulate(A, 0)
np.minimum.accumulate(A, 0)

cumsum(A, dims = 1)
accumulate(max, A, dims = 1)
accumulate(min, A, dims = 1)


Cumulative sum / max / min by column

cumsum(A, 2)
cummax(A, 2)
cummin(A, 2)

np.cumsum(A, 1)
np.maximum.accumulate(A, 1)
np.minimum.accumulate(A, 1)

cumsum(A, dims = 2)
accumulate(max, A, dims = 2)
accumulate(min, A, dims = 2)


## Programming¶

Operation

MATLAB

Python

Julia

Comment one line

% This is a comment

# This is a comment

# This is a comment


Comment block

%{
Comment block
%}

# Block
# comment
# following PEP8

#=
Comment block
=#


For loop

for i = 1:N
% do something
end

for i in range(n):
# do something

for i in 1:N
# do something
end


While loop

while i <= N
% do something
end

while i <= N:
# do something

while i <= N
# do something
end


If

if i <= N
% do something
end

if i <= N:
# do something

if i <= N
# do something
end


If / else

if i <= N
% do something
else
% do something else
end

if i <= N:
# do something
else:
# so something else

if i <= N
# do something
else
# do something else
end


Print text and variable

x = 10
fprintf('x = %d \n', x)

x = 10
print(f'x = {x}')

x = 10
println("x = \$x")


Function: anonymous

f = @(x) x^2

f = lambda x: x**2

f = x -> x^2
# can be rebound


Function

function out  = f(x)
out = x^2
end

def f(x):
return x**2

function f(x)
return x^2
end

f(x) = x^2 # not anon!


Tuples

t = {1 2.0 "test"}
t{1}


Can use cells but watch performance

t = (1, 2.0, "test")
t[0]

t = (1, 2.0, "test")
t[1]


Named Tuples/ Anonymous Structures

m.x = 1
m.y = 2

m.x

from collections import namedtuple

mdef = namedtuple('m', 'x y')
m = mdef(1, 2)

m.x

# vanilla
m = (x = 1, y = 2)
m.x

# constructor
using Parameters
mdef = @with_kw (x=1, y=2)
m = mdef() # same as above
m = mdef(x = 3)


Closures

a = 2.0
f = @(x) a + x
f(1.0)

a = 2.0
def f(x):
return a + x
f(1.0)

a = 2.0
f(x) = a + x
f(1.0)


Inplace Modification

function f(out, x)
out = x.^2
end
x = rand(10)
y = zeros(length(x), 1)
f(y, x)

def f(x):
x **=2
return

x = np.random.rand(10)
f(x)

function f!(out, x)
out .= x.^2
end
x = rand(10)
y = similar(x)
f!(y, x)