Changed julia to 1.6. Small changes in admonitions.

Author: VaclavMacha

docs/Project.toml

@@ -45,4 +45,4 @@ ProgressMeter = "1.4.1"
 Query = "1.0.0"
 RDatasets = "0.7.4"
 StatsPlots = "0.14.18"
-julia = "1.5"
+julia = "1.6"

docs/src/installation/git.md

@@ -16,7 +16,7 @@ There is no need to change the default settings. However, we recommend changing
 
 After setting the editor used by Git, finish the installation with default settings.
 
-!!! info "GitHub Account"
+!!! info "GitHub Account:"
     Create a GitHub account on the official [GitHub page](https://github.com/). Do not forget to verify your email address.
 
 ## User settings

docs/src/lecture_02/conditions.md

@@ -35,23 +35,14 @@ julia> compare(2.3, 2.3)
 x is equal to y
 ```
 
-```@raw html
-<div class="admonition is-info">
-<header class="admonition-header">Function declaration:</header>
-<div class="admonition-body">
-```
+!!! info "Function declaration:"
+    So far, we did not show how to define functions. However, the above example should show the basic syntax for defining functions. The `return` keyword specifies the function output. In this case, the function returns nothing since we only want to compare numbers. If we need to define a function that returns more than one variable, the following syntax is used.
 
-So far, we did not show how to define functions. However, the above example should show the basic syntax for defining functions. The `return` keyword specifies the function output. In this case, the function returns nothing since we only want to compare numbers. If we need to define a function that returns more than one variable, the following syntax is used.
+    ```julia
+    return x, y, z
+    ```
 
-```julia
-return x, y, z
-```
-
-Here `x`, `y`, and `z` are some variables. We will discuss the function declaration in more detail in the [next lesson](@ref Functions).
-
-```@raw html
-</div></div>
-```
+    Here `x`, `y`, and `z` are some variables. We will discuss the function declaration in more detail in the [next lesson](@ref Functions).
 
 The `elseif` and `else` keywords are optional. Moreover, it is possible to use as many `elseif` blocks as needed.
 
@@ -279,7 +270,7 @@ julia> f(1) || println(2) # both expressions are evaluated
 
 ```@raw html
 <div class="admonition is-info">
-<header class="admonition-header">Short-circuit evaluation vs. bitwise boolean operators</header>
+<header class="admonition-header">Short-circuit evaluation vs. bitwise boolean operators:</header>
 <div class="admonition-body">
 ```
 

docs/src/lecture_02/exercises.md

@@ -3,7 +3,7 @@
 So far, we used only the standard library shipped with Julia. However, the standard library provides only basic functionality. If we want to get additional functions, we have to use extra packages. There is a [Plots](https://github.com/JuliaPlots/Plots.jl) package for creating plots. Packages can be installed via Pkg REPL. To enter the Pkg REPL from the Julia REPL, press `]` and install the package by
 
 ```julia
-(@v1.5) pkg> add Plots
+(@v1.6) pkg> add Plots
 ```
 
 We need to use the `using` keyword to load the package. For example, we can use the Plots package to visualize the `sin` and `cos` functions.
@@ -225,13 +225,14 @@ Try different values of variable `c` to create different plots. For inspiration,
 
 ## Animation
 
-!!! warning "Warning"
+!!! warning "Warning:"
     It takes a lot of time to create the animation below, especially when using the default [GR](https://github.com/jheinen/GR.jl) backend for the Plots package. The plotting time can be reduced by using a different backend such as the [PyPlot](https://github.com/JuliaPy/PyPlot.jl) backend.
 
     ```julia
     using Plots, PyPlot
     pyplot()
     ```
+    
     The PyPlot package must be installed first. An alternative way is to use the [Makie](https://github.com/JuliaPlots/Makie.jl) package instead of the Plots package.
 
 We will now create an animation of the Julia sets for `c` defined as follows

docs/src/lecture_02/loops.md

@@ -48,7 +48,7 @@ i = 5
 
 ```@raw html
 <div class="admonition is-info">
-<header class="admonition-header">An alternative notation for <code>for</code> loops</header>
+<header class="admonition-header">An alternative notation for <code>for</code> loops:</header>
 <div class="admonition-body">
 ```
 

docs/src/lecture_03/exercises.md

@@ -17,6 +17,7 @@ The following few exercises will implement the Game of Life. We will consider fi
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Write a function `neighbours` that return the number of live neighbours of a cell. The function should accept the `world` matrix of boolean values representing the state of all cells (`true` if the cell is alive and `false` otherwise) and index of the row and column of the cell.
 
 **Hint:** use the following properties of the `mod1` function to implement periodic boundaries.
@@ -28,11 +29,13 @@ mod1(5, 4)
 ```
 
 **Bonus:** implement a more general function which computes the number of alive cells in a neighbourhood of given size.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
 <summary class = "solution-header">Solution:</summary><p>
 ```
+
 One way to define the `neighbours` function is to check all neighbours manually.
 
 ```julia
@@ -78,7 +81,9 @@ end
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Add a new method to the `neighbours` function that for the `world` matrix returns a matrix containing numbers of living neighbours.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
@@ -105,7 +110,9 @@ This is an example of multiple dispatch. The function `neighbours` can have both
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Write a function `willsurvive` that returns `true` if the cell will survive based on the conditions described at the beginning of the section and `false` otherwise. This function should accept two arguments: state of the cell (`true`/`false`) and the number of living neighbours.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
@@ -142,7 +149,9 @@ willsurvive(cell, k) = k == 3 || k == 2 && cell
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Combine these functions to write a function `evolve!` that evolves the given `world` matrix into a new generation.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">

docs/src/lecture_03/functions.md

@@ -90,9 +90,11 @@ julia> x3
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Write function `power(x::Real, p::Integer)` that for a number ``x`` and a (possibly negative) integer ``p`` computes ``x^p`` without using the `^` operator. Use only basic arithmetic operators `+`, `-`, `*`, `/` and the `if` condition. The annotation `p::Integer` ensures that the input `p` is always an integer.
 
 **Hint:** use recursion.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
@@ -210,9 +212,11 @@ However, for better code readability, the traditional multiline syntax is prefer
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Write a one-line function that returns `true` if the input argument is an even number and `false` otherwise.
 
 **Hint:** use modulo function and [ternary operator](@ref Ternary-operator) `?`.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
@@ -318,6 +322,7 @@ ERROR: UndefVarError: y not defined
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Write a function which computes the value of the following quadratic form
 
 ```math
@@ -331,6 +336,7 @@ a = 1, \quad b = 2a, \quad c = 3(a + b).
 ```
 
 What is the function value at point ``(4, 2)`` for default parameters? What is the function value at the same point if we use ``c = 3``?
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
@@ -426,6 +432,7 @@ julia> linear(2; a, b)
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Write a probability density function for the [Gaussian distribution](https://en.wikipedia.org/wiki/Normal_distribution)
 
 ```math
@@ -435,6 +442,7 @@ f_{\mu, \sigma}(x) = \frac{1}{\sigma \sqrt{ 2\pi }} \exp\left\{ -\frac{1}{2} \le
 where ``\mu \in \mathbb{R}`` and ``\sigma^2 > 0``. Use keyword arguments to obtain the standardized normal distribution (``\mu = 0`` and ``\sigma = 1``). Check that the inputs are correct.
 
 **Bonus:** verify that this function is a probability density function, i.e., its integral equals 1.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
@@ -598,11 +606,13 @@ This construction is beneficial whenever there are multiple chained functions, a
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Write a function `wrapper`, that accepts a number and applies one of `round`, `ceil` or `floor` functions based on the keyword argument `type`. Use the function to solve the following tasks:
 - Round `1252.1518` to the nearest larger integer and convert the resulting value to `Int64`.
 - Round `1252.1518` to the nearest smaller integer and convert the resulting value to `Int16`.
 - Round `1252.1518` to `2` digits after the decimal point.
 - Round `1252.1518` to `3` significant digits.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">

docs/src/lecture_03/methods.md

@@ -92,6 +92,7 @@ The problem with the `supertype` function is that it does not return the whole s
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Create a function `supertypes_tree` which prints the whole tree of all supertypes. If the input type `T` satisfies the following condition `T === Any`, then the function should do nothing. Use the following function declaration:
 
 ```julia
@@ -105,6 +106,7 @@ The optional argument `level` sets the printing indentation level.
 **Hints:**
 - Use the `supertype` function in combination with recursion.
 - Use the `repeat` function and string with white space `"    "` to create a proper indentation.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
@@ -166,6 +168,7 @@ This function suffers from a similar disadvantage as the `supertype` function: I
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 Create a function `subtypes_tree` which prints the whole tree of all subtypes for the given type. Use the following function declaration:
 
 ```@meta
@@ -185,11 +188,13 @@ The optional argument `level` sets the printing indentation level.
 **Hints:**
 - Use the `subtypes` function in combination with recursion.
 - Use the `repeat` function and string with white space `"    "` to create a proper indentation.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
 <summary class = "solution-header">Solution:</summary><p>
 ```
+
 The `subtypes_tree` function is similar to `supertypes_tree`. The only differences are that we do not need to check for the top level of `Any`, and that we need to call the vectorized version `subtypes_tree.` because `subtypes(T)` returns an array.
 
 ```jldoctest methods; output = false
@@ -320,9 +325,10 @@ Closest candidates are:
 
 ```@raw html
 <div class="admonition is-info">
-<header class="admonition-header">Do not overuse type annotation!!!</header>
+<header class="admonition-header">Do not overuse type annotation:</header>
 <div class="admonition-body">
 ```
+
 The `product` function should be defined without the type annotation. It is a good practice not to restrict input argument types unless necessary. The reason is that, in this case, there is no benefit of using the type annotation. It is better to define the function `product_new` by:
 
 ```jldoctest methods; output = false
@@ -360,19 +366,21 @@ ERROR: MethodError: no method matching *(::String, ::Symbol)
 ```
 
 Here we get a different error. However, the error returned by the `product_new` function is more useful because it tells us what the real problem is. We can see that it is impossible to use the `*` operator to multiply a `String` and a `Symbol`. We can decide if this is the desired behaviour, and if not, we can define a method for the `*` operator that will fix it.
+
 ```@raw html
 </div></div>
 ```
 
-
 We show a simple example when the multiple dispatch is useful.
 
 ```@raw html
 <div class="admonition is-category-exercise">
 <header class="admonition-header">Exercise:</header>
 <div class="admonition-body">
 ```
+
 We define the abstract type `Student` and specific types `Master` and `Doctoral`. The latter two are defined as structures containing one and three fields, respectively.
+
 ```@example methods
 abstract type Student end
 
@@ -388,13 +396,16 @@ end
 
 nothing # hide
 ```
+
 We can check that the `subtypes_tree` works correctly on any type, including the type `Student` which we defined.
+
 ```julia
 julia> subtypes_tree(Student)
 Student
    Doctoral
    Master
 ```
+
 We create instances of two students by providing values for the struct fields.
 
 ```@example methods
@@ -403,20 +414,25 @@ s2 = Doctoral(30000, 1, 0)
 
 nothing # hide
 ```
+
 Write the `salary_yearly` function which computes the yearly salary for both student types. The monthly salary is computed from the base salary (which can be accessed via `s1.salary`). Monthly bonus for doctoral students is 2000 for the mid exam and 1000 for the English exam.
+
 ```@raw html
 </div></div>
 <details class = "solution-body">
 <summary class = "solution-header">Solution:</summary><p>
 ```
+
 Julia prefers to write many simple functions. We write `salary_yearly` based on the not-yet-defined `salary_monthly` function.
+
 ```@example methods
 salary_yearly(s::Student) = 12*salary_monthly(s)
 
 nothing # hide
 ```
 
 We specified that the input to `salary_yearly` is any `Student`. Since `Student` is an abstract type, we can call `salary_yearly` with both `Master` and `Doctoral` student. Now we need to define the `salary_monthly` function. Since the salary is computed in different ways for both students, we write two methods.
+
 ```@example methods
 salary_monthly(s::Master) = s.salary
 salary_monthly(s::Doctoral) = s.salary + s.exam_mid*2000 + s.exam_english*1000
@@ -450,6 +466,7 @@ f (generic function with 2 methods)
 ```
 
 Here, `f` has two methods. The first method applies if the first argument is of type `Float64`, and the second method applies if the second argument is of type `Float64`.
+
 ```jldoctest methods_amb
 julia> f(2.0, 3)
 6.0

docs/src/lecture_04/DataFrames.md

@@ -41,15 +41,8 @@ col[1] = 4
 df
 ```
 
-```@raw html
-<div class="admonition is-info">
-<header class="admonition-header">Column names</header>
-<div class="admonition-body">
-```
-DataFrames allow using symbols (like `:A`) and strings (like `"A"`) for all column indexing operations. Using symbols is slightly faster and should be preferred. One exception is when the column names are generated using string manipulation.
-```@raw html
-</div></div>
-```
+!!! info "Column names:"
+    DataFrames allow using symbols (like `:A`) and strings (like `"A"`) for all column indexing operations. Using symbols is slightly faster and should be preferred. One exception is when the column names are generated using string manipulation.
 
 The standard format for storing table data is the `csv` file format. The [CSV](https://github.com/JuliaData/CSV.jl) package provides an interface for saving and loading `csv` files.