Selected Tools of Modern Theoretical Physics 1

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Julia Cheatsheet

REPL Modes

Key	Mode	Example
(default)	Julia	`1 + 1`
`?`	Help	`?sqrt`
`]`	Pkg	`add QuadGK`, `status`, `rm Foo`
`;`	Shell	`ls`, `pwd`

Variables & Types

x = 55699
x = 1 + 1im # complex number (no space before im)
x = 3.14 # Float64
x = true # Bool

typeof(x) # check type
eltype(x) # element type (for arrays)

Arithmetic & Math

2.0^2 # exponent (not **)
sqrt(9) # → 3.0 (Float64)
sqrt(Complex(-1.0)) # need complex input for complex result
div(8, 5) # integer division → 1
8 ÷ 5 # \div<tab>, same as div()
rem(8, 5) # remainder → 3
8 % 5 # same as rem()
abs(-3) # absolute value

Strings

s = "hello"
"$s world" # interpolation
"$s" * "!" # concatenation
length(s)
uppercase(s)
split("a b c") # → ["a", "b", "c"]

Functions

# Inline / anonymous
f = x -> 2 * x
square = x -> x^2

# Short form
f(x) = 2 * x

# Full form (preferred for non-trivial logic)
function f(x)
 return 2 * x
end

# Optional positional + keyword arguments
# positional optional must come before keywords
function f(x, y=2, z=3; a=4.0, b=5.0)
 println([x, y, z, a, b])
 return x + y + z^a + b
end

f(1)
f(1, 10, b=173, a=77)
f(1, 2, 4, b=173) # must specify y before z

# Splat a NamedTuple as keywords
opts = (a=5.0, b=3.0)
f(1, 2, 4; opts...)

# Pipe operator
2 |> square # → 4

# Broadcast (element-wise)
sin.(1:5)
@. sin(1:5)^2 # applies . to every operation

Control Flow

# if / elseif / else
if x > 0
 println("positive")
elseif x == 0
 println("zero")
else
 println("negative")
end

# Ternary
x > 0 ? "pos" : "non-pos"

# for loop
for i in 1:5
 println(i)
end

# while loop
i = 1
while i <= 5
 i += 1
end

# break / continue work as expected

Arrays & Vectors

# 1D (column vector)
v = [1, 2, 3]

# Row vector
r = [1 2 3]

# Concatenation
[v; v] # vertical (append rows)
[r r] # horizontal (append cols)

# Constructors
zeros(3) # [0.0, 0.0, 0.0]
ones(3)
rand(5) # uniform [0,1)
randn(5) # standard normal

# Ranges
r = 1:10 # lazy range
r = range(0.0, 1.0, length=50)
r = range(0.0, 1.0, step=0.1)

# Comprehensions & generators
arr = [x^2 for x in 1:10]
gen = (x^2 for x in 1:10) # lazy, no memory allocation
collect(gen) # materialize generator → array

# similar / fill
x1 = similar(arr)
fill!(x1, π)

# Useful operations
push!(v, 4) # append in-place
pop!(v) # remove last
append!(v, [5,6]) # append multiple
length(v)
sum(v); prod(v); maximum(v); minimum(v)

# Indexing (1-based)
v[1] # first element
v[end] # last element
v[2:4] # slice (returns copy)
v[2:end]

# eachindex — always prefer over 1:length(v)
# safe for any index type, offset arrays, etc.
for i in eachindex(v)
 v[i] *= 2
end

# iterate with both index and value
for (i, val) in enumerate(v)
 println("v[$i] = $val")
end

# iterate two arrays together
for (a, b) in zip(v, w)
 println(a + b)
end

# Broadcast
v .^ 2
@. sin(v)^4

Matrices

# Literal syntax (spaces = cols, semicolons = rows)
A = [1 2 3; 4 5 6] # 2×3 matrix

# Column-based construction
A = [[1,4,7] [2,5,8] [3,6,9]]

# From reshape
A = reshape(1:9, 3, 3) # NOTE: fills column-major

# Constructors
zeros(3, 3)
ones(2, 4)
rand(3, 3)
randn(3, 3)
Matrix{Float64}(undef, 3, 3) # uninitialized
Matrix(I, 3, 3) # identity (using LinearAlgebra)

# Indexing
A[1, 2] # row 1, col 2
A[:, 1] # entire first column
A[1, :] # entire first row

# Transpose
A' # adjoint (conjugate transpose)
transpose(A) # non-conjugate transpose

# Common operations (using LinearAlgebra)
using LinearAlgebra
A * B # matrix multiply
A .* B # element-wise multiply
inv(A)
tr(A) # trace
diag(A) # diagonal elements
det(A)
norm(A)
eigen(A) # eigendecomposition → .values, .vectors
eigvals(A)
eigvecs(A)
svd(A) # SVD

# Solve A*x = b
b = rand(3)
x = A \ b

Summation Patterns

N = 10

# Loop
ret = 0.0
for i in 1:N
 ret += 1 / i^2
end

# Array comprehension
ret = sum([1/i^2 for i in 1:N])

# Generator (no intermediate array allocated — preferred)
ret = sum(1/i^2 for i in 1:N)

# Broadcast shorthand
ret = sum(@. 1 / (1:N)^2)

Recursion

# Ternary (concise)
fac(n) = n == 1 ? 1 : n * fac(n - 1)

# Full form with type annotation
function fac(n::Int)
 n < 1 && error("n must be ≥ 1")
 return n == 1 ? 1 : n * fac(n - 1)
end

# Non-integer generalization: use gamma function
using SpecialFunctions
gamma(n + 1) # equals fac(n) for integer n

I/O

# User input
s = readline()
x = parse(Float64, readline())
n = parse(Int, readline())

# CSV (recommended for tabular data)
using CSV, DataFrames

df = DataFrame(rand(10, 3), :auto)
CSV.write("result.csv", df)
df = DataFrame(CSV.File("result.csv"))

# CSV with options
df = DataFrame(CSV.File("result.dat",
 comment="#", delim=" ", header=false))

# DelimitedFiles (lightweight, no DataFrame needed)
using DelimitedFiles

# Build data row-by-row (e.g. from a solver returning multiple outputs)
# _solver(x) returns a tuple/array; splat it with ...
data = []
for x_now in x_arr
 entry = [x_now, _solver(x_now)...] # flatten into one row
 push!(data, entry') # push as row vector
end
data = vcat(data...) # stack into matrix

open("result.dat", "w") do f
 write(f, "# x y z\n")
 writedlm(f, data)
end

data2 = readdlm("result.dat", comments=true)

# fetch columns by index
xvec = data2[:, 1]
yvec = data2[:, 2]

# Load a Julia file
include("./myfile.jl")

Plotting (Plots.jl)

using Plots

x = range(0, 2π, length=200)

p = plot(x, sin.(x), label="sin(x)", lw=2)
plot!(p, x, cos.(x), label="cos(x)", linestyle=:dash)

xlabel!("x"); ylabel!("y"); title!("Trig functions")

savefig(p, "fig.png") # or .pdf, .svg

Introspection & Performance

methods(*) # all methods for *
methods(*, [Int, Int]) # filtered by types
@less 2 + 2.0 # view source
@code_llvm 2 + 4.0 # LLVM IR
@code_native 1 + 1 # native assembly
@time f(x) # time + allocations
@allocated f(x) # allocations only
@benchmark f(x) # (BenchmarkTools.jl)

Further Resources

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Contributor Covenant Code of Conduct

Our Pledge

In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.

Our Standards

Examples of behavior that contributes to creating a positive environment include:

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

setup notes

preparation


# at top folder
hugo new site final
cd final

# install a theme
git submodule add -f https://github.com/panr/hugo-theme-hello-friend.git themes/hello-friend

# copy and paste config.toml and content from theme/hello-friend/exampleSite/ to the main directory
# check the see the basics are working

hugo version; hugo serve

fine tune the config.toml to your liking

dealing with _index.md in /content/

# put _index.md in /content/

hack the theme/hello-friend/layout/_default/baseof.html into


<!DOCTYPE html>
<html lang="{{ $.Site.Language }}">
 <head>
 {{ block "title" . }}
 <title>
 {{ if .IsHome }}{{ $.Site.Title }}{{ with $.Site.Params.Subtitle }} —
 {{ . }}{{ end }}{{ else }}{{ .Title }} ::
 {{ $.Site.Title }}{{ with $.Site.Params.Subtitle }} — {{ . }}{{ end }}{{ end }}
 </title>
 {{ end }}
 {{ partial "head.html" . }}
 </head>
 <body class="{{ if ne $.Site.Params.defaultTheme "light" -}} dark-theme {{- end -}}">
 <div class="container">
 {{ partial "header.html" . }}

 <div class="post">
 {{ .Content }}
 </div>

 {{ block "footer" . }}
 {{ partial "footer.html" . }}
 {{ end }}
 </div>

 {{ if $.Site.GoogleAnalytics }}
 {{ template "_internal/google_analytics.html" . }}
 {{ end }}
 </body>
</html>

Note that the “.Content” part is the key. Then save it as index.html in /layout/

cheatsheet

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Julia basic usage

# using package
using LinearAlgebra
using Plots

# assign variables
x = 55699
x = 1 + 1 * im # complex number
x = [1, 2, 3] # mutable list
x = [1 2; 3 4] # matrix

2.0^2 # not **
sqrt(9) # give Float64
sqrt(-1) # give error
sqrt(-1.0 + 0.0 * im) # need complex number input to get complex result

# ? to get help
# ] to enter pkg mode
# add QuadGK
# ; to enter shell

# include("./myfile.jl") to load a file

# divisor and remainder

div(8,5) # should be 1
8 ÷ 5 # \div<tab>

rem(8,5)
8 % 5

# function:

f = x -> 2 * x # in-line
# or
f(x) = 2 * x # lousy

# best
function f(x)
 return 2*x
end

# general way to construct a function
# std. form
function f(x)
 ret = 2 * x
 return ret
end

# with optional arguments 
# required, optional + sequential; optional keywords (arbitrary order)
function f(x, y = 2, z = 3; a = 4.0, b = 5.0)
 ret = x + y + z^a + b
 println([x, y, z, a, b])
 return ret
end
f(1)
f(1, 10, b = 173, a = 77)
# have to specify y before we can specify z
f(1, 2, 4, b = 173)

# use of NamedTuples
options = (a=5.0, b=3.0)
f(1, 2, 4; options...)

# evaluate a function
f = x->x^2
f(2)
# pipe it
2 |> f


rand() # uniform, 0 to 1
rand(10) # array of 10 random number
rand(2, 2) # 2 x 2 random matrix (real)

zeros(x) # suitable zero for the variable type of x
ones(x)

# code internal: multiple dispatch and type stability
methods(*, [Int, Int])
@less 2 + 2.0
@code_llvm 2 + 4.0
@code_native 1 + 1
# check type
typeof(x)
eltype(x)

# arrays and generators
N = 50
xmin = 0.0
xmax = 1.0
xarr = [xmin + (i1 - 1) * (xmax - xmin) / (N - 1) for i1 in 1:N]

# create an array with similar dimension and fill it with values
x1arr = similar(xarr)
fill!(x1arr, pi)

# similar construction but with a generator (iterator)
xarr = range(0.0, 1.0, length = 50)
xarr = range(0.0, 1.0, step = 1/49)

gen = (x^2 for x in xarr)

# convert a generator to an array
xarr = collect(gen)

# "." operation: on each element
xarr .^ 2
sin.(xarr)
# more convenient
@. sin(xarr)^4

[sin(xx)^4 for xx in range(0.0, 1.0, length = 50)]

# summation
# by standard loop
N = 10
ret = 0.0
for i1 in 1:N
 ret += 1 / i1^2
end

# with list
ret = sum([1 / i1^2 for i1 in 1:N])

# really condensed notation
ret = sum(@. 1 / (1:N)^2)

# cool way to write recursive function
# 3-way if statement
fac(N) = N == 1 ? 1 : N * fac(N - 1)

function fac1(N::Int)
 if N == 1
 ret = 1
 else
 ret = N * fac1(N - 1)
 end
 return ret
end

# what if N is not an integer?
using SpecialFunctions
gamma(N + 1) # :D
methods(gamma)

# list construction

data = []
for i1 in 1:10
 push!(data, i1)
end
data = [x for x in 1:10]

# matrix operation
x = [1 2; 3 4]
y = rand(2, 2)

x * y
inv(x)
sqrt(x)
exp(x)
log(x)
tr(x)
diag(x)

eigen(x)
eigvals(x)
eigvecs(x)

# A * x = b
A = rand(2,2)
b = rand(2)
A \ b

# asking user for input
char = readline()
ff = parse(Float64, readline())
i1 = parse(Int, readline())

# simple I/O (write to & read from file)

# prepare your data in whatever way
# e.g. 10 rows, 3 columns
df = DataFrame(rand(10, 3), :auto)

# DataFrames & CSV (recommended)
using CSV

# to write
CSV.write("result.dat", df)

# to read
df = CSV.File("result.dat")

# nice looking dataset
df
push!(df, [1, 2, 3])
df.x1
df.x2

# in REPL, ; to shell for further manipulation of the datafile.

# useful options: 
# comment with #, spaces as delimiters, no header, etc.
dataf = CSV.File(
 "result.dat",
 comment = "#",
 delim = " ",
 header = false
)

# DelimitedFiles
# see delimited files https://docs.julialang.org/en/v1/stdlib/DelimitedFiles/

using DelimitedFiles
# to write
f(x, y) = x * y
data = []
for i1 in 1:10
 x = i1
 y = rand()
 push!(data, [x, y, f(x, y)]') # entry as column then transposed
 # push!(data, [x y f(x, y)]) # entry as row
end
data = vcat(data...) # turn data into a matrix

# to get the 2nd column
data[:, 2]

filename = "result.dat"
open(filename, "w") do f
 Base.write(f, "# some captions \n")
 writedlm(f, data)
end

# to read, comments like #... are ignored
file = filename
data2 = readdlm(file, comments = true)

data2 == data
# to fetch, e.g. xvec
xvec = data[:, 1]

# quick plot
rval = 2.5
p1 = plot(xarr, x -> x^2, label="r=$rval, \\alpha is alpha")
title("title of plot")
legend(["line 1", "line 2"], "northwest")
savefig(p1, "fig.png") # or pdf

# ways to get the same matrix
mat1 = [1 2 3; 4 5 6; 7 8 9]
mat1[1, 3]

# column based thinking
mat2 = [[1, 4, 7] [2, 5, 8] [3, 6, 9]]

# reshape
mat3 = [i1 for i1 in 1:9]
mat3 = reshape(mat3, (3, 3))
mat3'

# eachindex

xv = range(0, 1, lenght=250)

ret = 0.0
for i1 in eachindex(xv)
 ret += xv[i1]
end

further resources

Fall 2026 (on-going)

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Python / Julia / Programming Basics

Differential Equations I

Solution to Schroedinger equations

Homeworks

(please attach the source files of programs)

hw01; grade

miniProject

project guide

stacks

Julia: tips and tricks

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

install Julia via juliaup

curl -fsSL https://install.julialang.org | sh

New to Julia? Look at the cheatsheet

Veteran looking for challenges? check it out

python reminder

many ways to loop

for i1 in 1:N1, i2 in 1:N2
 # do something for mat[i1, i2]
end

# col. major, faster
for i2 in 1:N2, i1 in 1:N1
 # do something for mat[i1, i2]
end

sites = Base.product(1:N1, 1:N2)

for site in sites
 i1, i2 = site
 # do something
end

no more side effect

try the following code

Linux

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

useful stuffs

shortcuts for shell

ctrl + k: cut from here to end
ctrl + u: cut from here to start
ctrl + y: yank it
ctrl + a: jump to the beginning
ctrl + e: jump to the end
ctrl + p: (p)revious line
ctrl + n: (n)ext line
sudo !!: sudo the last command
see tutoriaLinux for more

List of Pluto files

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

This list keeps expanding (Caution: sliders will not work in the html version. Run them locally.)

NumQM2021

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Exploring Quantum Many Body Systems with Modern Numerical Tools

Instructor

Pok Man Lo
428 Institute of Theoretical Physics, University of Wroclaw
pokman.lo@urw.edu.pl
course website
github pages
consultation hours: Mon 1500-1600 Wed 1500-1700

Course Description

This is a graduate course on applying numerical method to study aspects of quantum many body problems. It aims to develop or reinforce programming skills, numerical analysis skills, familiarity with some important problems in quantum many body physics, and their methods of solution.

python reminder

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

generator for integrals

inte = sum(f(xvec) * xweight)

is much faster than

inte = 0
for i1, xval in enumerate(xvec):
 inte += f(xval) * xweight[i1]

generator for nested sum

cast a nested sum into one big iterator:

simple case:


N1 = 5
N2 = 8
p1_arr = np.linspace(0.8, 1.2, N1)
p2_arr = np.linspace(3.8, 4.5, N2)

grid = (
 (i1, i2)
 for i1 in range(N1) for i2 in range(N2)
 )

ans = (
 _f(p1_arr[i1], p2_arr[i2])
 for i1, i2 in grid
 )

ans = sum(ans)

further processing:

N1 = 10
N2 = 80
para1_arr = np.linspace(0.8, 1.2, N1)
para2_arr = np.linspace(3.6, 4.0, N2)

grid = (
 (i1, i2)
 for i1 in range(N1) for i2 in range(N2)
 )

pool = [
 [fitfunc([para1_arr[i1], para2_arr[i2]]), i1, i2]
 for i1, i2 in grid
 ]
pool = np.array(pool).T

_ii = np.argmin(pool[0])
i1, i2 = int(pool[1][_ii]), int(pool[2][_ii])

print(para1_arr[i1], para2_arr[i2])

passing tuple as index for array

lat[tuple([*xvec, d])]
lat[xvec[0], xvec[1], xvec[2], xvec[3], d]

data stacking

data = vstack((data, new_col))

filename versioning

filename=f'file_{int(num):03}'

watch out for side effects

import numpy as np

# test 1
xarr = [1, 2, 3]
yarr = [2, 4, 6]
a = xarr
a += yarr
# Guess what xarr becomes now?

# test 2
xarr = np.array([1, 2, 3])
yarr = np.array([2, 4, 6])
a = xarr
a += yarr
# Guess what xarr becomes now?

This can be a hard bug to track down!

Resources

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Free Lunch

Fool’s collection

Fool’s rule

Physics

Student Research Projects

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

(come and ask!)

Gluons in Dense Matter

Lattice QCD with Julia

Confinement Models of Quarks and Gluons

explore various ways to model confinement
color group structure

Scattering Theory and Quark Hadron Duality

the roles of quarks and gluons in hadron phenomenology
VMD in chiral quark models
manifestations of chiral symmetry

Hadron Yields in Heavy Ion Collisions

the Hadron Resonance Gas Model and working towards its improvement
kinetic theory from field theory
in-medium hadron masses from S-matrix

Aspects of Constituent Quark Models

quarkonia and tetraquarks
form factors, decays, and mixing
coupled-channel model

Non-perturbative field theory

Schwinger Dyson equations in Minkowski space
effects of boundary conditions

Topics in Quantum Mechanics

supersymmetric quantum mechanics
path integral
Emilia’s notes
constituent quark model

Syllabus

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Numerical methods for Babies

In this course the programming language of choice is Julia. (As interactive as Python, but as fast as C.) No previous experience with Julia is assumed and we will pick up the syntaxes along the way. Of course, some familiarity with at least one programming language (Python, C, C++, Fortran, etc.) would be a big plus.

Topics

Introduction

Gentle introduction to Julia language

REPL, Pluto / Jupyter NoteBooks, and Scripts
program flow, style guide
basic data types, struct, etc.
mutables and immutables: arrays, tuples
iterators and generators
scope and typeof
type instability
tips on writing efficient code

Basic skills of applied computational physics

integration: Gaussian quadrature
differentiation: finite difference, complex-step, ect.
linear algebra
differential equations
minimization

Introduction to Monte Carlo Methods

Ising model

Simulating a Pure Gauge System

Basic Machine learning

Z2 gauge theory

noreply@numqm.local (Pok Man Lo) — Mon, 01 Jan 0001 00:00:00 +0000

Sample code to study Z2 gauge theory

julia

function main(Ns = 40, dim = 4)

 latt = ones(Int64, ntuple(i1 -> i1 <= dim ? Ns : dim, dim + 1))
 links = CartesianIndices(latt)

 function mvup(x::CartesianIndex, d)
 # key routine to optimize: KISS
 f1(i1) = x[i1]
 f2(i1) = x[i1] == Ns ? 1 : x[i1] + 1
 f(i1) = i1 != d ? f1(i1) : f2(i1)
 return CartesianIndex(ntuple(f, length(x)))

 end

 function mvdown(x::CartesianIndex, d)
 # key routine to optimize: KISS
 f1(i1) = x[i1]
 f2(i1) = x[i1] == 1 ? Ns : x[i1] - 1
 f(i1) = i1 != d ? f1(i1) : f2(i1)
 return CartesianIndex(ntuple(f, length(x)))

 end

 function coldstart()
 latt .= 1
 end

 function randomstart()
 latt .= rand([-1, 1])
 end

 function staplecal(link::CartesianIndex)

 x = CartesianIndex(link.I[1:end-1])
 d = link.I[end]

 # following M. Creutz
 # staples around link(1->4)
 # dperp 6--5
 # ^ | |
 # | 1--4
 # | | |
 # -----> d 2--3

 staplesum = 0.0
 for dperp = 1:length(x)
 if dperp != d

 # plaquette 1234
 x = mvdown(x, dperp)
 link1 = latt[x, dperp]
 link2 = latt[x, d]
 x = mvup(x, d)
 link3 = latt[x, dperp]
 x = mvup(x, dperp)
 # plaquette 4561
 link4 = latt[x, dperp]
 x = mvup(x, dperp)
 x = mvdown(x, d)
 link5 = latt[x, d]
 x = mvdown(x, dperp)
 link6 = latt[x, dperp]
 staplesum += link1 * link2 * link3 + link4 * link5 * link6

 end
 end
 return staplesum
 end

 function update(beta)

 action = 0.0
 for link in links

 staplesum = staplecal(link)
 # calculate the Boltzmann weight
 bplus = exp(beta * staplesum * 1)
 bplus /= (bplus + 1 / bplus)

 # the heatbath algorithm
 if rand() < bplus
 latt[link] = 1
 action += staplesum
 else
 latt[link] = -1
 action -= staplesum
 end
 end

 return 1.0 - action / Ns^dim / dim / 6.0
 end

 beta_arr1 = range(1, stop = 0, length = 20)
 beta_arr2 = range(0, stop = 1, length = 20)

 coldstart()
 # randomstart()
 println("#cold -> hot")
 for beta in beta_arr1
 println(beta, " ", update(beta))
 end

 # already hot
 println("#hot -> cold")
 for beta in beta_arr2
 println(beta, " ", update(beta))
 end

end

@time main()

python


import numpy as np
import itertools

# N = 20 is already slow
N = 20
latt = np.ones(N**4*4).reshape([N, N, N, N, 4])

rng = np.random.default_rng()


# utility
def moveup(xvec, d):
 # xvec is mutable
 xvec[d] += 1
 xvec[d] = xvec[d] % N # stays between [0, 1, ..., N-1]
 return None


def movedown(xvec, d):
 # xvec is mutable
 xvec[d] -= 1
 xvec[d] = xvec[d] % N
 return None


def coldstart():
 latt[:] = 1
 return None


def randomstart():

 sites = itertools.product(range(N), range(N), range(N), range(N), range(4))

 for site in sites:

 spin = rng.integers(2)
 if spin == 0:
 spin = -1

 latt[site] = spin

 return None


def update(beta):

 sites = itertools.product(range(N), range(N), range(N), range(N), range(4))

 action = 0.

 for site in sites:

 *x, d = site

 # following M. Creutz
 # staples around link(1->4)
 # dperp 6--5
 # ^ | |
 # | 1--4
 # | | |
 # -----> d 2--3

 staplesum = 0.
 for dperp in range(4):
 if dperp != d:

 # plaquette 1234
 movedown(x, dperp)
 staple = latt[x[0], x[1], x[2], x[3], dperp]
 staple *= latt[x[0], x[1], x[2], x[3], d]
 moveup(x, d)
 staple *= latt[x[0], x[1], x[2], x[3], dperp]
 moveup(x, dperp)
 staplesum += staple

 # plaquette 4561
 staple = latt[x[0], x[1], x[2], x[3], dperp]
 moveup(x, dperp)
 movedown(x, d)
 staple *= latt[x[0], x[1], x[2], x[3], d]
 movedown(x, dperp)
 staple *= latt[x[0], x[1], x[2], x[3], dperp]
 staplesum += staple


 # calculate the Boltzmann weight
 bplus = np.exp(beta*staplesum)
 bminus = np.exp(-beta*staplesum)
 bplus = bplus/(bplus+bminus)

 # the heatbath algorithm
 r = rng.uniform()

 if r < bplus:
 latt[site] = 1
 action += staplesum
 else:
 latt[site] = -1
 action -= staplesum

 return 1. - action/N**4/4./6.


def main():

 # beta_c = 0.44

 beta_arr1 = np.linspace(1., 0., 40)
 beta_arr2 = np.linspace(0., 1., 40)

 coldstart()
 print('# cold -> hot')
 for beta in beta_arr1:
 action = update(beta)
 print(beta, action)

 # already hot
 print('# hot -> down')
 for beta in beta_arr2:
 action = update(beta)
 print(beta, action)

 return None


main()

fortran 90

program main
 use iso_fortran_env
 implicit none
 integer, parameter :: dp = REAL64

 integer, parameter :: N = 40
 integer, dimension(N,N,N,N,4) :: latt

 real(dp) :: beta
 real(dp) :: dbeta = 0.01
 real(dp) :: actionS
 integer :: i1

 ! coldstart
 latt = 1

 ! cold -> hot
 do i1 = 1, 100
 beta = 1. - i1*dbeta
 call sweep(N, beta, latt, actionS)
 print*, beta, actionS
 end do

 ! hot -> cold
 do i1 = 1, 100
 beta = i1*dbeta
 call sweep(N, beta, latt, actionS)
 print*, beta, actionS
 end do

 contains

 subroutine moveup(xvec, d, N)
 implicit none
 integer, intent(in) :: d
 integer, intent(in) :: N
 integer, dimension(4), intent(inout) :: xvec
 xvec(d) = xvec(d) + 1
 if(xvec(d) > N) then
 xvec(d) = xvec(d) - N
 else
 end if
 end subroutine moveup

 subroutine movedown(xvec, d, N)
 implicit none
 integer, intent(in) :: d
 integer, intent(in) :: N
 integer, dimension(4), intent(inout) :: xvec
 xvec(d) = xvec(d) - 1
 if(xvec(d) < 1) then
 xvec(d) = xvec(d) + N
 else
 end if
 end subroutine movedown

 subroutine sweep(N, beta, lat, actionS)

 use iso_fortran_env
 implicit none
 integer, parameter :: dp = REAL64

 integer, intent(in) :: N
 real(dp), intent(in) :: beta
 integer, dimension(N,N,N,N,4), intent(inout) :: lat
 real(dp), intent(out) :: actionS

 integer :: i1, i2, i3, i4, d, dperp
 real(dp) :: r_num
 real(dp), dimension(N,N,N,N,4):: rand_arr

 integer, dimension(4) :: xvec
 real(dp) :: staple
 real(dp) :: staplesum
 real(dp) :: bplus
 real(dp) :: bminus

 call random_seed()
 call random_number(rand_arr)

 actionS = 0.
 do i1 = 1, N
 do i2 = 1, N
 do i3 = 1, N
 do i4 = 1, N
 do d = 1, 4

 xvec = [ i1, i2, i3, i4 ]

 staplesum = 0.
 do dperp = 1, 4
 if (dperp /= d) then
 call movedown(xvec, dperp, N)
 staple = lat(xvec(1), xvec(2), xvec(3), xvec(4), dperp)
 staple = staple*lat(xvec(1), xvec(2), xvec(3), xvec(4), d)
 call moveup(xvec, d, N)
 staple = staple*lat(xvec(1), xvec(2), xvec(3), xvec(4), dperp)
 call moveup(xvec, dperp, N)
 staplesum = staplesum + staple

 staple = lat(xvec(1), xvec(2), xvec(3), xvec(4), dperp)
 call moveup(xvec, dperp, N)
 call movedown(xvec, d, N)
 staple = staple*lat(xvec(1), xvec(2), xvec(3), xvec(4), d)
 call movedown(xvec, dperp, N)
 staple = staple*lat(xvec(1), xvec(2), xvec(3), xvec(4), dperp)
 staplesum = staplesum + staple
 else
 end if
 end do

 bplus = exp(beta * staplesum)
 bminus = exp(-beta * staplesum)
 bplus = bplus / (bplus + bminus)

 r_num = rand_arr(i1, i2, i3, i4, d)
 !call random_number(r_num)

 if (r_num <= bplus) then
 lat(i1, i2, i3, i4, d) = 1
 actionS = actionS + staplesum/N**4/24.
 else
 lat(i1, i2, i3, i4, d) = -1
 actionS = actionS - staplesum/N**4/24.
 end if

 end do
 end do
 end do
 end do
 end do

 actionS = 1. - actionS

 end subroutine sweep

end program main

c (from M. Creutz)

/* Z_2 lattice gauge simulation */
/* Michael Creutz <creutz@bnl.gov> */
/* http://thy.phy.bnl.gov/~creutz/z2.c */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* the lattice is of dimensions SIZE**4 */
#define SIZE 40
int link[SIZE][SIZE][SIZE][SIZE][4]; /* last index gives link direction */

/* utility functions */
void moveup(int x[],int d) {
 x[d]+=1;
 if (x[d]>=SIZE) x[d]-=SIZE;
 return;
}
void movedown(int x[],int d) {
 x[d]-=1;
 if (x[d]<0) x[d]+=SIZE;
 return;
}
void coldstart(){ /* set all links to unity */
 int x[4],d;
 for (x[0]=0;x[0]<SIZE;x[0]++)
 for (x[1]=0;x[1]<SIZE;x[1]++)
 for (x[2]=0;x[2]<SIZE;x[2]++)
 for (x[3]=0;x[3]<SIZE;x[3]++)
 for (d=0;d<4;d++)
 link[x[0]][x[1]][x[2]][x[3]][d]=1;
 return;
}
/* for a random start: call coldstart() and then update once at beta=0 */

/* do a Monte Carlo sweep; return energy */
double update(double beta){
 int x[4],d,dperp,staple,staplesum;
 double bplus,bminus,action=0.0;
 for (x[0]=0; x[0]<SIZE; x[0]++)
 for (x[1]=0; x[1]<SIZE; x[1]++)
 for (x[2]=0; x[2]<SIZE; x[2]++)
 for (x[3]=0; x[3]<SIZE; x[3]++)
 for (d=0; d<4; d++) {
 staplesum=0;
 for (dperp=0;dperp<4;dperp++){
 if (dperp!=d){
 /* move around thusly:
 dperp 6--5
 ^ | |
 | 1--4
 | | |
 -----> d 2--3 */
 /* plaquette 1234 */
 movedown(x,dperp);
 staple=link[x[0]][x[1]][x[2]][x[3]][dperp]
 *link[x[0]][x[1]][x[2]][x[3]][d];
 moveup(x,d);
 staple*=link[x[0]][x[1]][x[2]][x[3]][dperp];
 moveup(x,dperp);
 staplesum+=staple;
 /* plaquette 1456 */
 staple=link[x[0]][x[1]][x[2]][x[3]][dperp];
 moveup(x,dperp);
 movedown(x,d);
 staple*=link[x[0]][x[1]][x[2]][x[3]][d];
 movedown(x,dperp);
 staple*=link[x[0]][x[1]][x[2]][x[3]][dperp];
 staplesum+=staple;
 }
 }
 /* calculate the Boltzmann weight */
 bplus=exp(beta*staplesum);
 bminus=1/bplus;
 bplus=bplus/(bplus+bminus);
 /* the heatbath algorithm */
 if ( drand48() < bplus ){
 link[x[0]][x[1]][x[2]][x[3]][d]=1;
 action+=staplesum;
 }
 else{
 link[x[0]][x[1]][x[2]][x[3]][d]=-1;
 action-=staplesum;
 }
 }
 action /= (SIZE*SIZE*SIZE*SIZE*4*6);
 return 1.-action;
}

/******************************/
int main(){
 double beta, dbeta, action;
 srand48(1234L); /* initialize random number generator */
 /* do your experiment here; this example is a thermal cycle */
 dbeta=.01;
 coldstart();
 /* heat it up */
 for (beta=1; beta>0.0; beta-=dbeta){
 action=update(beta);
 printf("%g\t%g\n",beta,action);
 }
 printf("\n\n");
 /* cool it down */
 for (beta=0; beta<1.0; beta+=dbeta){
 action=update(beta);
 printf("%g\t%g\n",beta,action);
 }
 printf("\n\n");
 exit(0);
}

cpp

// Z2 4D lattice
// cpp adaptation of M. Creutz C code
//

# include <stdio.h>
# include <stdlib.h>
# include <math.h>
# include <iostream>
# include <random>

using namespace std;

// the lattice is of dimensions SIZE**4
#define SIZE 40

class config {

 private:
 double lattice[SIZE][SIZE][SIZE][SIZE][4];
 public:
 // basic feature of lattice_config
 config ();

 void coldstart();
 void randomstart();
 double staplecal(const int *y, int d);
 double sweep(double beta);

 };

config::config(){
 int x[4];
 int d;
 for (x[0]=0;x[0]<SIZE;x[0]++)
 for (x[1]=0;x[1]<SIZE;x[1]++)
 for (x[2]=0;x[2]<SIZE;x[2]++)
 for (x[3]=0;x[3]<SIZE;x[3]++)
 for (d=0;d<4;d++){
 lattice[x[0]][x[1]][x[2]][x[3]][d]=1.;}
 return;
}

// utility
//
// move +1 step along d-th direction
void moveup(int *x, int d) {
 x[d] = x[d] + 1;
 if (x[d]>=SIZE) x[d]=x[d]-SIZE;
 return;
}

void movedown(int *x, int d) {
 x[d] = x[d] - 1;
 if (x[d]<0) x[d]=x[d]+SIZE;
 return;
}


void config::coldstart()
 {
 int x[4];
 int d;

 for (x[0]=0;x[0]<SIZE;x[0]++)
 for (x[1]=0;x[1]<SIZE;x[1]++)
 for (x[2]=0;x[2]<SIZE;x[2]++)
 for (x[3]=0;x[3]<SIZE;x[3]++)
 for (d=0;d<4;d++){
 lattice[x[0]][x[1]][x[2]][x[3]][d]=1.;}
 return;
 }


void config::randomstart()
 {
 int x[4],d;
 // usage: unif(rng) to get a random number
 std::uniform_real_distribution<double> unif(0., 1.);
 std::random_device rand_dev; // Use random_device to get a random seed.
 std::mt19937_64 rng(rand_dev()); // mt19937 is a good pseudo-random number generator.

 for (x[0]=0; x[0]<SIZE; x[0]++)
 for (x[1]=0; x[1]<SIZE; x[1]++)
 for (x[2]=0; x[2]<SIZE; x[2]++)
 for (x[3]=0; x[3]<SIZE; x[3]++)
 for (d=0; d<4; d++)
 {
 if ( unif(rng) > 0.5 ){
 lattice[x[0]][x[1]][x[2]][x[3]][d]=1.;
 }
 else{
 lattice[x[0]][x[1]][x[2]][x[3]][d]=-1.;
 }
 }
 return;
 }

// staple calculation
double config::staplecal(const int *y, int d)
 {
 double staple,staplesum;
 int x[4];
 int dperp;

 // copy the address of current site
 x[0] = y[0];
 x[1] = y[1];
 x[2] = y[2];
 x[3] = y[3];

 staplesum=0.;
 for (dperp=0;dperp<4;dperp++){
 if (dperp!=d){
 /* move around thusly:
 dperp 6--5
 ^ | |
 | 1--4
 | | |
 -----> d 2--3 */
 /* plaquette 1234 */
 movedown(x,dperp);
 staple=lattice[x[0]][x[1]][x[2]][x[3]][dperp]
 *lattice[x[0]][x[1]][x[2]][x[3]][d];
 moveup(x,d);
 staple=staple*lattice[x[0]][x[1]][x[2]][x[3]][dperp];
 moveup(x,dperp);
 staplesum=staplesum+staple;
 /* plaquette 1456 */
 staple=lattice[x[0]][x[1]][x[2]][x[3]][dperp];
 moveup(x,dperp);
 movedown(x,d);
 staple=staple*lattice[x[0]][x[1]][x[2]][x[3]][d];
 movedown(x,dperp);
 staple=staple*lattice[x[0]][x[1]][x[2]][x[3]][dperp];
 staplesum=staplesum+staple;
 }
 }

 return staplesum;
 }

 // do one Monte Carlo sweep
 double config::sweep(double beta)
 {

 int x[4],d;
 double staplesum;
 double bplus,bminus;
 double action = 0.0;

 double current_link;

 // usage: unif(rng) to get a random number
 std::uniform_real_distribution<double> unif(0., 1.);
 std::random_device rand_dev; // Use random_device to get a random seed.
 std::mt19937_64 rng(rand_dev()); // mt19937 is a good pseudo-random number generator.

 for (x[0]=0; x[0]<SIZE; x[0]++)
 for (x[1]=0; x[1]<SIZE; x[1]++)
 for (x[2]=0; x[2]<SIZE; x[2]++)
 for (x[3]=0; x[3]<SIZE; x[3]++)
 for (d=0; d<4; d++)
 {

 staplesum = staplecal(x, d);

 /* calculate the Boltzmann weight */
 bplus=exp(beta*staplesum);
 bminus=exp(-1.*beta*staplesum);
 bplus=bplus/(bplus+bminus);
 /* the heatbath algorithm */
 if ( unif(rng) < bplus ){
 lattice[x[0]][x[1]][x[2]][x[3]][d]=1.;
 action +=staplesum;
 }
 else{
 lattice[x[0]][x[1]][x[2]][x[3]][d]=-1.;
 action -=staplesum;
 }
 }
 action /= (SIZE*SIZE*SIZE*SIZE*4*6);
 return 1.-action;
 }


int main(){

 // parameters
 double beta_min = 0.;
 double beta_max = 1.;
 const int N_beta = 100;
 double action = 0.;
 double beta, dbeta;

 //static config current;
 static config current;

 dbeta= (beta_max-beta_min)/(N_beta);
 current.coldstart();
 //current.randomstart();
 /* heat it up */
 for (beta=beta_max; beta>beta_min; beta-=dbeta){
 action = current.sweep(beta);
 cout << beta << " " << action << endl;
 }

 /* cool it down */
 for (beta=beta_min; beta<beta_max; beta+=dbeta){
 action = current.sweep(beta);
 cout << beta << " " << action << endl;
 }

 return 0;
}