# Loops

# Loops¶

In `Julia`

there are two types of loops, `for`

and `while`

.
As of `Julia 1.5`

(here you can find a longer discussion on the implemented changes), the behavior of those loops are very similar to loops known in other programming languages.

`for`

loops repeat a finite number evaluations, which is equal to the number of elements of the provided iterable object.
Ranges and arrays are examples of iterable objects.
One very simple `for`

loop:

```
for i in [1 2 3 4]
println("i=$i")
end
```

```
i=1
i=2
i=3
i=4
```

The loop iterates over elements of the array `[1 2 3 4]`

. For each iteration the value of the iterator `i`

is changed to the subsequent element of the iterable object.

if you use two-dimensional arrays, the order of elements is chosen *columnwisely*.

```
A = [1 2; 3 4]
```

```
2×2 Matrix{Int64}:
1 2
3 4
```

```
for i in A
println("i=$i")
end
```

```
i=1
i=3
i=2
i=4
```

Loops can be nested:

```
for x ∈ 1:3
for y ∈ 1:2
println("x^y=$(x^y), for x=$x and y=$y.")
end
end
```

```
x^y=1, for x=1 and y=1.
x^y=1, for x=1 and y=2.
x^y=2, for x=2 and y=1.
x^y=4, for x=2 and y=2.
x^y=3, for x=3 and y=1.
x^y=9, for x=3 and y=2.
```

The same thing can be written in a more compact way:

```
for x ∈ 1:3, y ∈ 1:2
println("x^y=$(x^y), for x=$x and y=$y.")
end
```

```
x^y=1, for x=1 and y=1.
x^y=1, for x=1 and y=2.
x^y=2, for x=2 and y=1.
x^y=4, for x=2 and y=2.
x^y=3, for x=3 and y=1.
x^y=9, for x=3 and y=2.
```

The conditional mapping of elements of the vector from our previous example, can be solved also using a `for`

loop:

```
x = collect(1:10)
y = similar(x) #the object of the same size and type as x
for i ∈ 1:length(x)
y[i] = x[i]%2==0 ? -x[i]^2 : x[i]^2+1
end
println("y=$y")
```

```
y=[2, -4, 10, -16, 26, -36, 50, -64, 82, -100]
```

Instead of using `i ∈ 1:length(x)`

, we can use `(i,xᵢ) ∈ enumerate(x)`

.
Using this approach, the `for`

loop creates one iterator equal to a counter starting at `1`

and one iterator `xᵢ`

equal to subsequent values of `x`

:

```
y2 = similar(x)
for (i,xᵢ) ∈ enumerate(x)
y2[i] = xᵢ%2==0 ? -xᵢ^2 : xᵢ^2+1
end
println("y2=$y2")
```

```
y2=[2, -4, 10, -16, 26, -36, 50, -64, 82, -100]
```

The most compact way to perform this operation is to use an *inline for loop*.
This type of loops has the following structure

`[operations for iterator in iterable_object ]`

.In our example this will be:

```
y = [ xᵢ%2==0 ? -xᵢ^2 : xᵢ^2+1 for xᵢ ∈ x ]
```

```
10-element Vector{Int64}:
2
-4
10
-16
26
-36
50
-64
82
-100
```

I presented several ways of solving the discussed problem.
Personally, I am the biggest fan of using a functional approach involving `map`

: `map(arg -> arg%2==0 ? -arg^2 : arg^2+1 , x)`

.
The reason for this is that this approach is easier to be nested inside pipes, discussed later.

`while`

loops are a traditional alternative to `for`

loops.
This loop is executed as long as the provided condition is true.
If the condition is not met, then the execution is terminated.

```
i = 0
while i ≤ 5
println("i=$i")
i+=1;
end
```

```
i=0
i=1
i=2
i=3
i=4
i=5
```

The `for`

loop can imitate this behavior by combination of `break`

and conditional statement.
The main difference is that it has the maximum number of iterations equal to the size of the iterable object, in the case below equal to \(1000.\)

```
i = 0
for κ ∈ 1:1000
println("i=$i")
i+=1;
if i>5 #termination condition
break
end
end
```

```
i=0
i=1
i=2
i=3
i=4
i=5
```

Command `break`

terminates the current iteration of the loop and executes further code.

In this example we take negation of `i≤5`

. To directly use this condition, we can use `continue`

and `break`

. `continue`

tells `Julia`

to finish the current iteration of the loop (in the current line!) and to start a new iteration.

```
i = 0
for κ ∈ 1:1000
println("i=$i")
i+=1;
if i≤5
continue
else
break
end
1+2+3 #this part of the loop is never executed.
end
```

```
i=0
i=1
i=2
i=3
i=4
i=5
```

Last and maybe the least, we can use short-circuit evaluations discussed here to make the code more compact.

```
i = 0
for κ ∈ 1:1000
println("i=$i")
i+=1;
i≤5 || break #termination condition. `break` is executed when `i≤5` is false
end
```

```
i=0
i=1
i=2
i=3
i=4
i=5
```