---
marp: true
---

# Julia for Data Analysis

## Chapter 2: Getting started with Julia

### Bogumił Kamiński

https://github.com/bkamins/JuliaForDataAnalysis

---

# Outline

1. Values
2. Variables
3. Control flow
3.1. Conditional evaluation
3.2. Loops
3.3. Compound expressions
4. Defining functions
5. Scoping rules

---

# Values

* A *value* is a representation of some entity that is stored in computer's
memory and can be manipulated by Julia program.
* Every value is a result of evaluation of some Julia expression.
* Example values created by evaluation of *literals*:

```
julia> 0.1
0.1

julia> "Hello world!"
"Hello world!"

julia> [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3
```

---

# Types

* Each value has a type, which you can check using the `typeof` function.
* When you define a function you optionally can define the types of arguments
  that the function accepts.
* Example types of values:

```
julia> typeof(0.1)
Float64

julia> typeof("Hello world!")
String

julia> typeof([1, 2, 3])
Vector{Int64} (alias for Array{Int64, 1})
```

---

# Checking memory layout of numbers

* Numbers in Julia can have different types (e.g. `Int64`, `Float64`, `Int8`).
* Each such type can use a different memory layout to represent the same
  mathematical value.
* Examples of representation of *one*:

```
julia> bitstring(1)
"0000000000000000000000000000000000000000000000000000000000000001"

julia> bitstring(1.0)
"0011111111110000000000000000000000000000000000000000000000000000"

julia> bitstring(Int8(1))
"00000001"
```

---

# Integer type

On 64-bit machines integers in Julia by default use 64-bit representation
(`Int64` type). As a shorthand you can use `Int` alias type name instead:

```
julia> Int
Int64
```

---

# Container types typically have parameters in Julia

```
julia> typeof([1, 2, 3])
Vector{Int64} (alias for Array{Int64, 1})
```

* `Vector{Int64}` tells us that `[1, 2, 3]` is a vector that can store
  integer numbers; the `Int64` part is a parameter of `Vector`;
* `Array{Int64, 1}` is another way to write the same; now we have two parameters:
   1. element type that our array can store (`Int64`, an integer);
   2. dimension of our array (`1`, a vector).

---

# Checking if value has some type

You can check if some value has some type using the `isa` operator:

```
julia> [1, 2, 3] isa Vector{Int}
true

julia> [1, 2, 3] isa Array{Int64, 1}
true
```

---

# Variables

* You can bind a value to a variable name using the assignment operator `=`:

```
julia> x = 1
1

julia> y = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3
```

* The process of binding does not involve copying of values.
  Python also follows this approach.
  In R this is not the case.

---

# Only values have types in Julia

You can, in general assign values of different types to the same variable name:

```
julia> x = 1
1

julia> typeof(x)
Int64

julia> x = 0.1
0.1

julia> typeof(x)
Float64
```

Although this is allowed it is usually not recommended.

---

# You can use Unicode characters in variable names

```
julia> Kamiński = 1
1

julia> x₁ = 0.5
0.5

julia> ε = 0.0001
0.0001
```

In Julia REPL, VS Code ect., you can easily type such characters:

```
help?> ₁
"₁" can be typed by \_1<tab>

help?> ε
"ε" can be typed by \varepsilon<tab>
```

---

# The `if` statement

```
julia> x = -7
-7

julia> if x > 0
           println("positive")
       elseif x < 0
           println("negative")
       elseif x == 0
           println("zero")
       else
           println("unexpected condition")
       end
negative
```

---

# Conditions must be Boolean values

```
julia> x = -7
-7

julia> if x
           println("condition was true")
       end
ERROR: TypeError: non-boolean (Int64) used in boolean context
```

---

# Be careful with numeric comparisons of floats

```
julia> NaN > 0
false

julia> NaN < 0
false

julia> NaN == 0
false

julia> NaN != 0
true

julia> NaN != NaN
true

julia> 0.1 + 0.2 == 0.3
false
```

---

# Combining logical conditions with `&&` and `||`

```
julia> x = -7
-7

julia> x > 0 && x < 10
false

julia> x < 0 || log(x) > 10
true
```

---

# Short-circut evaluation

`&&` and `||` evaluate only as many conditions (starting from the leftmost) as
is needed to determine the logical value of the whole expression.

```
julia> x = -7
-7

julia> log(x)
ERROR: DomainError with -7.0:
log will only return a complex result if called with a complex argument. Try log(Complex(x)).

julia> x < 0 || log(x) > 10
true
```

---

# One-line conditional evaluation using `&&` and `||`

The codes below use short-circut evaluation:

```
julia> x = -7
-7

julia> x < 0 && println(x^2)
49

julia> iseven(x) || println("x is odd")
x is odd
```

---

# Ternary operator

Julia supports the *ternary operator* borrowed from the C programming language.

```
x > 0 ? sqrt(x) : sqrt(-x)
```

is equivalent to writing:

```
if x > 0
    sqrt(x)
else
    sqrt(-x)
end
```

---

# Conditional statements return a value

```
julia> x = -4.0
-4.0

julia> y = if x > 0
               sqrt(x)
           else
               sqrt(-x)
           end
2.0

julia> y
2.0
```

---

# Example `for` loop

```
julia> for i in [1, 2, 3]
           println(i, " is ", isodd(i) ? "odd" : "even")
       end
1 is odd
2 is even
3 is odd
```

---

# Example `while` loop

```
julia> i = 1
1

julia> while i < 4
           println(i, " is ", isodd(i) ? "odd" : "even")
           global i += 1
       end
1 is odd
2 is even
3 is odd
```

We use `global` keyword in the loop as we want to update the `i` variable which
is in global scope.

---

# Standard `break` and `continue` keywords are supported in loops

```
julia> i = 0
0

julia> while true
           global i += 1
           i > 6 && break
           isodd(i) && continue
           println(i, " is even")
       end
2 is even
4 is even
6 is even
```

---

# Compound expression using `begin`-`end` block

```
julia> x = -7
-7

julia> x < 0 && begin
           println(x)
           x += 1
           println(x)
           2 * x
       end
-7
-6
-12
```

The value of the compound expression is the value of the last expression
inside it (`-12` in our case).

---

# Compound expression using semicolon `;`

If your code is short you can wrap several expressions in parentheses
and separate them using semicolon `;`:

```
julia> x = -7
-7

julia> x > 0 ? (println(x); x) : (x += 1; println(x); x)
-5
-5
```

---

# You can use the `function` keyword to define a function

```
julia> function times_two(x)
           return 2 * x
       end
times_two (generic function with 1 method)

julia> times_two(10)
20
```

---

# Functions allow positional and keyword arguments separated by `;` with optional default values

```
julia> function compose(x, y=10; a, b=10)
           return x, y, a, b
       end
compose (generic function with 2 methods)

julia> compose(1, 2; a=3, b=4)
(1, 2, 3, 4)

julia> compose(1, 2; a=3)
(1, 2, 3, 10)

julia> compose(1; a=3)
(1, 10, 3, 10)

julia> compose(1)
ERROR: UndefKeywordError: keyword argument a not assigned

julia> compose(; a=3)
ERROR: MethodError: no method matching g(; a=3)
```

---

# Passing arguments to functions in Julia

If you pass a value to a function Julia performs a binding of the function
argument name to this value. This feature is called *pass-by-sharing* and means
that Julia never copies data when arguments are passed to a function.

This is a behavior that you might know from Python, but is different from e.g.,
R, where copying of function arguments is performed.

---

# Short syntax for creation simple functions

You can use the assignment operator to create one-line functions:

```
julia> times_two(x) = 2 * x
times_two (generic function with 1 method)

julia> compose(x, y=10; a, b=10) = x, y, a, b
compose (generic function with 2 methods)
```

---

# Functions are first class objects in Julia

You can pass functions as arguments to other functions:

```
julia> map(times_two, [1, 2, 3])
3-element Vector{Int64}:
 2
 4
 6
```

---

# You can define anonymous functions using the `->` operator

```
julia> map(x -> 2 * x, [1, 2, 3])
3-element Vector{Int64}:
 2
 4
 6

julia> sum(x -> x ^ 2, [1, 2, 3])
14
```

---

# Julia supports `do` blocks

If a function takes another function as its first argument you can conveniently
define it using a `do` block:

```
julia> sum([1, 2, 3]) do x
           println("processing ", x)
           return x ^ 2
       end
processing 1
processing 2
processing 3
14
```

---

# The `!` character in function names

Often you will see an exclamation mark (`!`) at the end of the function name,
e.g., `sort!`. There is a convention that developers are recommended to add `!`
at the end of the functions they create if such functions modify their arguments.

```
julia> x = [5, 1, 3, 2];

julia> sort(x); # returns a new vector; x is not changed

julia> sort!(x); # changes x in-place
```

---

# Variable scoping rules in Julia (simplified)

The following constructs we have learned till now create a new scope (*local scope*):
* functions, anonymous functions, `do`-`end` blocks;
* `for` and `while` loops.

Notably the `if` blocks and the `begin`-`end` blocks do not introduce a new
scope. This means that variables defined in such blocks leak out to the
enclosing scope.