{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-e39dce2363a3b28b",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"# Programming in Julia\n",
"\n",
"This notebook will teach you some of the basic programming routines in Julia. You will need these skills to complete the probabilistic programming assignments later on in the course. We will assume basic familiarity with programming, such as for-loops, if-else statements and function definitions.\n",
"\n",
"Resources:\n",
"- [Julia documentation](https://docs.julialang.org/en/v1/)\n",
"- [Differences to Python, Matlab, C and Java](https://docs.julialang.org/en/v1/manual/noteworthy-differences/)\n",
"- [Video on getting started](https://www.youtube.com/watch?v=4igzy3bGVkQ&list=PLP8iPy9hna6SCcFv3FvY_qjAmtTsNYHQE)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-3c2e8eba10e12225",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Data types\n",
"\n",
"- References: [Numbers](https://docs.julialang.org/en/v1/base/numbers/), [Integers and Float](https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/), [Strings](https://docs.julialang.org/en/v1/base/strings/), [Symbols](https://docs.julialang.org/en/v1/manual/metaprogramming/).\n",
"\n",
"Numbers in Julia have specific types, most notably `Integer`, `Real` and `Complex`. It is important to be aware of what type your numbers are because many functions operate differently on different number types. "
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Int64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"a = 3\n",
"typeof(a)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-2778002073c87b29",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"`Int64` is a 64-byte integer. Other options are 32-,16-, or 8-bit integers and they can be unsigned as well. The default real-valued numbers is a 64-bit floating-point number:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Float64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"a = 3.0\n",
"typeof(a)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-b4f29642d811571a",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Converting number types is easy:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Float64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"a = convert(Float64, 2)\n",
"typeof(a)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-ed3bc3a833acccd0",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Strings are constructed by enclosing symbols within double parentheses."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"String"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"a = \"3\"\n",
"typeof(a)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-c1be2e1ea2b90c34",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"They can be concatenated by multiplication (which is an example of a function, namely `*`, which acts differently on different input argument types): "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\"ab\""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"ab = \"a\"*\"b\""
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-76b62f36bf62f546",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"You can incorporate numbers into strings through a `$` call:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\"a = 3\""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"\"a = $a\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Julia also has a `Symbol` type, which is used for [meta-programming](https://docs.julialang.org/en/v1/manual/metaprogramming/) (not important for this course). A `Symbol` type is characterized by a `:` in front of a word. For example:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Symbol"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"s = :foo\n",
"typeof(s)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You will not have to use `Symbol`s in the course, but you may see one every once in a while in the lecture notes. For example, the `plot` command (see Visualization section), may have a `markershape=:cross` argument."
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-597f95a479025e8a",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Array manipulation\n",
"\n",
"- References: [Arrays](https://docs.julialang.org/en/v1/base/arrays/)\n",
"\n",
"Arrays are indexed with square brackets, `A[i,j]`. You can construct a matrix by enclosing a set of numbers with square brackets. If you separate your numbers with comma's, then you will get a column vector:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4-element Vector{Int64}:\n",
" 1\n",
" 2\n",
" 3\n",
" 4"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = [1,2,3,4]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-55802261c54cb78c",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"If you use spaces, then you will construct a row vector (i.e., a matrix of dimensions 1 by n):"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1×4 Matrix{Int64}:\n",
" 1 2 3 4"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = [1 2 3 4]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-0797fa9c8ec1c27d",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Matrices can be constructed by separating elements with spaces and rows by semicolons:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2×2 Matrix{Int64}:\n",
" 1 2\n",
" 3 4"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"X = [1 2; 3 4]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-752e17ff7e221dc6",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Common array constructors are:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2×3 Matrix{Float64}:\n",
" 1.89942 1.58604 0.790389\n",
" -0.243699 0.464712 -0.0802384"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"X = zeros(2,3)\n",
"Y = ones(2,3)\n",
"Z = randn(2,3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-2842d71d3b6fef26",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Matrix operations are intuitive and similar to the mathematical notation:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3-element Vector{Int64}:\n",
" 4\n",
" 7\n",
" 8"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"A = [3 2 1; 2 3 2; 1 2 3]\n",
"x = [0, 1, 2]\n",
"b = A*x"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-5ef3ae2aa92ab37c",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"A matrix can be transposed by a single parenthesis, `A'`. Note that this does not mutate the array in memory. It just tells functions defined for matrices that it should change how it indexes the matrix's elements."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"23"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"c = x'*A*x"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-07efb0f4ef442665",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Broadcasting\n",
"\n",
"- Reference: [Broadcasting](https://docs.julialang.org/en/v1/manual/arrays/#Broadcasting)\n",
"\n",
"You can apply functions to elements in an array by placing a dot in front:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1×3 Matrix{Int64}:\n",
" 3 6 9"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
" 3 .*[1 2 3]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-31680dda8e3c1644",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"This also works for named functions:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3-element Vector{Float64}:\n",
" 0.8414709848078965\n",
" 0.9092974268256817\n",
" 0.1411200080598672"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"sin.([1., 2., 3.])"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-86a74a70e6d21c8d",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Iteration\n",
"\n",
"- Reference: [Collections](https://docs.julialang.org/en/v1/base/collections/)\n",
"\n",
"For-loops are one of the simplest forms of iteration and can be defined in a number of ways. First, the matlab way:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"3\n",
"5\n"
]
}
],
"source": [
"for n = 1:2:5\n",
" println(n)\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-f584f54f4771da9f",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Next, we can use the `range` command to construct an array of numbers and then use the `in` command to loop over elements in the array:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.0\n",
"4.0\n"
]
}
],
"source": [
"num_range = range(0, stop=4, length=2)\n",
"for n in num_range\n",
" println(n)\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-3dcbd8a0da6ff030",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"If you need both the index and the value of the array element, you can use the `enumerate` command:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1, 0.0\n",
"2, 4.0\n"
]
}
],
"source": [
"for (j,n) in enumerate(num_range)\n",
" println(\"$j, $n\")\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-009da1637a8bd0de",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"You may be familiar with \"list comprehension\", which is a shortened form of iterating through a collection:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2-element Vector{String}:\n",
" \"n = 0.0\"\n",
" \"n = 4.0\""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"[\"n = $n\" for n in num_range]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-46cbf7bfca3c6d76",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Control flow\n",
"\n",
"- References: [Control flow](https://docs.julialang.org/en/v1/manual/control-flow/), [Logical Operators](https://docs.julialang.org/en/v1/manual/missing/#Logical-operators)\n",
"\n",
"Control flow refers to redirecting how a compiler goes through a program. Instead of traversing it line-by-line, things like `if-else` statements can make a compiler skip steps. These require logical operations: you can use `==` to check if two variables have the same value, `===` to check if they are actually the same object (i.e., same memory reference) and `!=` to check if they're not equal."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Positive\n"
]
}
],
"source": [
"a = 3.0\n",
"if a < 0 \n",
" println(\"Negative\")\n",
"elseif a == 0\n",
" println(\"0.0\")\n",
"else \n",
" println(\"Positive\")\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-44cf3744dc8b7ea8",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Simple `if-else` statements can often be replaced by `ternary` checks. Essentially, you ask a question (a logical operation followed by `?`) and then tell the program what to do when the answer is yes (written immediately after the question) or no (written after the yes-answer followed by a `:`)."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Positive\n"
]
}
],
"source": [
"a > 0 ? println(\"Positive\") : println(\"Not positive\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-2bd8fafa975e39df",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Functions\n",
"\n",
"- References: [Functions](https://docs.julialang.org/en/v1/manual/functions/), [Mutation](https://docs.julialang.org/en/v1/manual/style-guide/#bang-convention)\n",
"\n",
"Function and expressions are a core component of the julia language. Its \"multiple dispatch\" feature means that you can define multiple functions with the same name but with behaviour that depends on the input argument types. When you're starting out, you may not notice this so much, but you will start to appreciate this feature tremendously when you begin to professionally develop software."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\"Bah!\""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"function foo(bar::Float64)\n",
" message = \"Boo!\"\n",
" return message\n",
"end\n",
"\n",
"function foo(bar::Integer)\n",
" message = \"Bah!\"\n",
" return message\n",
"end\n",
"\n",
"foo(1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-89334d50f79b3b6e",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Note that the `return` argument does not need to be at the end of a function ([the return keyword](https://docs.julialang.org/en/v1/manual/functions/#The-return-Keyword)).\n",
"\n",
"You don't actually need the `function` keyword if you have simple enough functions:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.25"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fn(x::Number) = 1/x\n",
"fn(4)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-52be8f7c7644d2ae",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"You can add keyword arguments to a function, which are input arguments with default values:"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1×2 Matrix{Float64}:\n",
" 1.0 0.333333"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fn(; number::Number = 1) = 1/number\n",
"[fn() fn(number=3)]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-fdc3777677dd70d6",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Functions that modify their input arguments instead of creating new output variables are typically marked with an `!`. Below I have defined an unsorted vector and I call `sort` to sort it in increasing order. If I call the sort function and the original vector, then they will be different:"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3×2 Matrix{Int64}:\n",
" 1 1\n",
" 2 3\n",
" 3 2"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = [1, 3, 2]\n",
"[sort(x) x]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-4d68be5af3628fca",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"But if I call the `sort!` function and the original vector, you'll see that the original vector is now also sorted."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3×2 Matrix{Int64}:\n",
" 1 1\n",
" 2 2\n",
" 3 3"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"[sort!(x) x]"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-e1a8e25a1191dbc5",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Software packages\n",
"\n",
"- Reference: [Packages and modules](https://docs.julialang.org/en/v1/manual/faq/#Packages-and-Modules)\n",
"\n",
"Just like with Python, there are thousands of additional software packages that can be imported to provide specific functionalities. You'll encounter some of the most common ones throughout the course. \n",
"\n",
"We have provided an \"environment\" that automatically downloads all the packages you need throughout the course. The three lines of code below point to the environment specification itself, a Project.toml file containing a list of packages, and construct the environment. If the specified packages are not installed, then these will be automatically added. This will take a bit of time the first time you run it, but it will only take a few seconds afterwards."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-108da214ac7e1c99",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m new project at `~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks`\n",
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/Project.toml`\n",
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/Manifest.toml`\n"
]
}
],
"source": [
"using Pkg\n",
"Pkg.activate(\".\")\n",
"Pkg.instantiate();"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-7697dde5851e63b9",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Below are some examples of importing packages and using their added functionalities."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}\n",
"values:\n",
"2-element Vector{Float64}:\n",
" -0.6853720883753125\n",
" 4.085372088375313\n",
"vectors:\n",
"2×2 Matrix{Float64}:\n",
" 0.476976 -0.878916\n",
" -0.878916 -0.476976"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"using LinearAlgebra\n",
"\n",
"E,V = eigen([3. 2.;2. 0.4])"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
1×3 DataFrame
Row
a
b
c
Int64
Int64
Int64
1
1
2
3
"
],
"text/latex": [
"\\begin{tabular}{r|ccc}\n",
"\t& a & b & c\\\\\n",
"\t\\hline\n",
"\t& Int64 & Int64 & Int64\\\\\n",
"\t\\hline\n",
"\t1 & 1 & 2 & 3 \\\\\n",
"\\end{tabular}\n"
],
"text/plain": [
"\u001b[1m1×3 DataFrame\u001b[0m\n",
"\u001b[1m Row \u001b[0m│\u001b[1m a \u001b[0m\u001b[1m b \u001b[0m\u001b[1m c \u001b[0m\n",
" │\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\u001b[90m Int64 \u001b[0m\n",
"─────┼─────────────────────\n",
" 1 │ 1 2 3"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"using DataFrames\n",
"\n",
"x = Dict(\n",
" \"a\" => 1,\n",
" \"b\" => 2,\n",
" \"c\" => 3\n",
")\n",
"\n",
"df = DataFrame(x)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.10798193302637613"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"using Distributions\n",
"\n",
"px = Normal(1.0, 0.5)\n",
"pdf(px, 0.0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-25086ec01e8644ce",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Visualization\n",
"\n",
"- Reference: [Plots.jl](https://github.com/JuliaPlots/Plots.jl)\n",
"\n",
"Plots.jl provides a common interface to call various other visualization backends (GR, Matplotlib, PGFPlotsX, Plotly, etc.). In other words, commands like `plot(..)` will be translated into the appropriate command for the backend. So, it does not re-invent the wheel but rather gives you access to the already enormous field of visualization tools.\n",
"\n",
"Below are a few examples of the most common visualization commands you'll see throughout the course. The core principle is to use a `plot` type as base command and then provide keyword arguments (in `String`, `Number` or `Symbol` type) to apply variations."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"image/svg+xml": [
"\n",
"\n"
],
"text/html": [
"\n",
"\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"using Plots\n",
"\n",
"x = range(-3, stop=3, length=301)\n",
"plot(x, pdf.(px, x), xlabel=\"x\", ylabel=\"p(x)\", label=\"pdf\", color=\"red\", linewidth=5, linestyle=:dash)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`plot` and `scatter` are the most useful commands. A `scatter` command will ignore properties such as `linewidth` and `linestyle` (since there are no lines) and will listen to `markersize` and `markershape` commands (see [Supported Attributes](https://docs.juliaplots.org/stable/generated/supported/) in the API)."
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"image/svg+xml": [
"\n",
"\n"
],
"text/html": [
"\n",
"\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"X = randn(10,2)\n",
"scatter(X[:,1], X[:,2], xlabel=\"X_1\", ylabel=\"X_2\", markersize=10, markershape=:cross)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is possible to add plots to the same figure by using a `!` added to your plot command."
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"image/svg+xml": [
"\n",
"\n"
],
"text/html": [
"\n",
"\n"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot(x, pdf.(Normal(0.,1.), x), xlabel=\"x\", ylabel=\"p(x)\", label=\"N(0,1)\", color=\"red\", linewidth=5, linestyle=:dash)\n",
"plot!(x, pdf.(Normal(1.,0.5), x), xlabel=\"x\", ylabel=\"p(x)\", label=\"N(1,0.5)\", color=\"blue\", linestyle=:solid)"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-60386ddc6157fdbb",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"## Macro's\n",
"\n",
"- References: [Macros](https://docs.julialang.org/en/v1/manual/metaprogramming/#man-macros)\n",
"\n",
"Words that start with the `@` symbol are \"macro\"'s in Julia, for example `@time, @test, @model`. They represent a series of functions called on an input structure and are really handy when you have to use the same set of instructions often. \n",
"\n",
"For example, you could define a `ProgressMeter` bar, update it at every iteration of a for-loop and write a custom print statement every time. _Or_, you could call the `@showprogress` macro on the for-loop itself:"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:02\u001b[39m\u001b[K\n"
]
}
],
"source": [
"using ProgressMeter\n",
"\n",
"@showprogress for n in 1:10\n",
" sleep(0.1)\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {
"nbgrader": {
"grade": false,
"grade_id": "cell-76339cb21a5934f5",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
}
},
"source": [
"Macro's are a somewhat advanced form of metaprogramming. You will not need to define any new macro's; this instruction is just here to explain what they are."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Errors\n",
"\n",
"- References: [Stack traces](https://docs.julialang.org/en/v1/manual/stacktraces/)\n",
"\n",
"When you call a function that Julia doesn't know, it will return a list of the steps it took to execute your command and point to where its progress was blocked. This is highly useful but it typically requires a bit of practice to parse (i.e., read and filter) stack traces.\n",
"\n",
"Suppose we write a function that expects an `Integer` input and call that function with an `Float64` argument:"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"ename": "MethodError",
"evalue": "MethodError: no method matching add1(::Float64)\n\nClosest candidates are:\n add1(!Matched::Integer)\n @ Main ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y123sZmlsZQ==.jl:1\n",
"output_type": "error",
"traceback": [
"MethodError: no method matching add1(::Float64)\n",
"\n",
"Closest candidates are:\n",
" add1(!Matched::Integer)\n",
" @ Main ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y123sZmlsZQ==.jl:1\n",
"\n",
"\n",
"Stacktrace:\n",
" [1] top-level scope\n",
" @ ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y123sZmlsZQ==.jl:5"
]
}
],
"source": [
"function add1(a::Integer)\n",
" return a + 1\n",
"end\n",
"\n",
"add1(3.0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that we first of all get a `MethodError`. This points to the fact that Julia could not find the function (i.e, method) that you asked for; `add1(::Float64)` does not exist.\n",
"\n",
"Furthermore, Julia provides a list of \"Closest candidates\" which are functions of the same name with different input arguments. It reports:\n",
"```\n",
"Closest candidates are:\n",
" add1(!Matched::Integer)\n",
"```\n",
"\n",
"You should read this as \"there exists a function called `add1` that expects an `Integer` input.\" Try that."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"add1(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `!Matched` is also important but requires a slightly more complicated example. Suppose we have a function with two `Integer` inputs and we call with `Float64` and `Int64` arguments."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"ename": "MethodError",
"evalue": "MethodError: no method matching add(::Float64, ::Int64)\n\nClosest candidates are:\n add(!Matched::Integer, ::Integer)\n @ Main ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y130sZmlsZQ==.jl:1\n",
"output_type": "error",
"traceback": [
"MethodError: no method matching add(::Float64, ::Int64)\n",
"\n",
"Closest candidates are:\n",
" add(!Matched::Integer, ::Integer)\n",
" @ Main ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y130sZmlsZQ==.jl:1\n",
"\n",
"\n",
"Stacktrace:\n",
" [1] top-level scope\n",
" @ ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y130sZmlsZQ==.jl:5"
]
}
],
"source": [
"function add(a::Integer, b::Integer)\n",
" return a+b\n",
"end\n",
"\n",
"add(3.0,4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We again get the `MethodError` that the function we asked for doesn't exist and a suggested alternative (i.e., \"closest candidate\"). But note that in that alternative, `add(!Matched::Integer, ::Integer)`, only one of the inputs is `!Matched`. So, in fact, Julia check your input argument types against those in the closest candidates. This tells you _what_ to change: if you change the first argument of your function call to an `Integer` type, then this closest candidate will be evaluated.\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"add(3,4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To summarize, when you get an error, it is important to read the stack trace. It may tell you that you need only change a small thing for your code to work."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The type of error can also be informative. The `MethodError` is probably the error you will see most often. Another important error is the `UndefVarError`, which occurs when you call a variable that was not defined. For example:"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"ename": "UndefVarError",
"evalue": "UndefVarError: `aa` not defined",
"output_type": "error",
"traceback": [
"UndefVarError: `aa` not defined\n",
"\n",
"Stacktrace:\n",
" [1] top-level scope\n",
" @ ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y135sZmlsZQ==.jl:1"
]
}
],
"source": [
"y = 3*aa"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The solution to this, of course, is to define the variable first. Sometimes this error occurs through a spelling mistake. You will encounter objects in the course called `MvNormalMeanCovariance`. If you misremember that name and write `MvNormalMeanVariance`, this will happen:"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"ename": "UndefVarError",
"evalue": "UndefVarError: `MvNormalMeanVariance` not defined",
"output_type": "error",
"traceback": [
"UndefVarError: `MvNormalMeanVariance` not defined\n",
"\n",
"Stacktrace:\n",
" [1] top-level scope\n",
" @ ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y140sZmlsZQ==.jl:1"
]
}
],
"source": [
"aa = MvNormalMeanVariance()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Next to errors, it is also important to check line numbers in a stack trace. For example, the cell below contains a mistake and evaluating it will throw an error. But which line has the mistake?"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"ename": "UndefVarError",
"evalue": "UndefVarError: `xx` not defined",
"output_type": "error",
"traceback": [
"UndefVarError: `xx` not defined\n",
"\n",
"Stacktrace:\n",
" [1] top-level scope\n",
" @ ~/syndr/Wouter/Onderwijs/Vakken/tueindhoven/5SSD0 - Bayesian Machine Learning & Information Processing/2024-2025 Q2/BMLIP/lessons/notebooks/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_Y142sZmlsZQ==.jl:3"
]
}
],
"source": [
"yy = 3*2\n",
"zz = 3*yy\n",
"xx = yy*xx\n",
"zz = yy*xx"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"At the end of the line, right after the specific function call there is a `: `, which will tell you where to look."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Closing\n",
"\n",
"That's it for now. If you encounter mysterious errors, please let us know on [Piazza](https://piazza.com/tue.nl/winter2025/5ssd0). We can add them to this primer."
]
}
],
"metadata": {
"celltoolbar": "Raw Cell Format",
"kernelspec": {
"display_name": "Julia 1.10.6",
"language": "julia",
"name": "julia-1.10"
},
"language_info": {
"file_extension": ".jl",
"mimetype": "application/julia",
"name": "julia",
"version": "1.10.6"
}
},
"nbformat": 4,
"nbformat_minor": 4
}