- Julia Tutorial
- Julia - Home
- Julia - Overview
- Julia - Environment Setup
- Julia - Basic Syntax
- Julia - Arrays
- Julia - Tuples
- Integers & Floating-Point Numbers
- Julia - Rational & Complex Numbers
- Julia - Basic Operators
- Basic Mathematical Functions
- Julia - Strings
- Julia - Functions
- Julia - Flow Control
- Julia - Dictionaries & Sets
- Julia - Date & Time
- Julia - Files I/O
- Julia - Metaprogramming
- Julia - Plotting
- Julia - Data Frames
- Working with Datasets
- Julia - Modules and Packages
- Working with Graphics
- Julia - Networking
- Julia - Databases
- Julia Useful Resources
- Julia - Quick Guide
- Julia - Useful Resources
- Julia - Discussion

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

As we know that each line of a program in Julia is evaluated in turn hence it provides many of the control statements (familiar to other programming languages) to control and modify the flow of evaluation.

Following are different ways to control the flow in Julia programming language −

Ternary and compound expressions

Boolean switching expressions

If elseif else end (conditional evaluation)

For end (iterative evaluation)

While end (iterative conditional evaluation)

Try catch error throw (exception handling)

Do blocks

It takes the form **expr ? a : b**. It is called ternary because it takes three arguments. The **expr** is a condition and if it is true then **a** will be evaluated otherwise **b**. Example for this is given below −

julia> A = 100 100 julia> A < 20 ? "Right" : "wrong" "wrong" julia> A > 20 ? "Right" : "wrong" "Right"

As the name implies, the Boolean switching expression allows us to evaluate an expression if the condition is met, i.e., the condition is true. There are two operators to combine the condition and expression −

If this operator is used in the Boolean switching expression, the second expression will be evaluated if the first condition is true. If the first condition is false, the expression will not be evaluated and only the condition will be returned.

**Example**

julia> isodd(3) && @warn("An odd Number!") ┌ Warning: An odd Number! └ @ Main REPL[5]:1 julia> isodd(4) && @warn("An odd Number!") false

If this operator is used in the Boolean switching expression, the second expression will be evaluated only if the first condition is false. If the first condition is true, then there is no need to evaluate the second expression.

**Example**

julia> isodd(3) || @warn("An odd Number!") true julia> isodd(4) || @warn("An odd Number!") ┌ Warning: An odd Number! └ @ Main REPL[8]:1

We can also use **if, elseif,** and **else** for conditions execution. The only condition is that all the conditional construction should finish with **end**.

julia> fruit = "Apple" "Apple" julia> if fruit == "Apple" println("I like Apple") elseif fruit == "Banana" println("I like Banana.") println("But I prefer Apple.") else println("I don't know what I like") end I like Apple julia> fruit = "Banana" "Banana" julia> if fruit == "Apple" println("I like Apple") elseif fruit == "Banana" println("I like Banana.") println("But I prefer Apple.") else println("I don't know what I like") end I like Banana. But I prefer Apple.

Some of the common example of iteration are −

working through a list or

set of values or

from a start value to a finish value.

We can iterate through various types of objects like arrays, sets, dictionaries, and strings by using “**for**” loop (**for…end** construction). Let us understand the syntax with the following example −

julia> for i in 0:5:50 println(i) end 0 5 10 15 20 25 30 35 40 45 50

In the above code, the variable ‘i’ takes the value of each element in the array and hence will step from 0 to 50 in steps of 5.

In case if we iterate through array, it is checked for change each time through the loop. One care should be taken while the use of ‘**push!**’ to make an array grow in the middle of a particular loop.

julia> c = [1] julia> 1-element Array{Int64,1}: 1 julia> for i in c push!(c, i) @show c sleep(1) end c = [1,1] c = [1,1,1] c = [1,1,1,1] ...

**Note** − To exit the output, press Ctrl+c.

Loop variable is a variable that steps through each item. It exists only inside the loop. It disappears as soon as the loop finishes.

julia> for i in 0:5:50 println(i) end 0 5 10 15 20 25 30 35 40 45 50 julia> i ERROR: UndefVarError: i not defined

Julia provides **global** keyword for remembering the value of the loop variable outside the loop.

julia> for i in 1:10 global hello if i % 3 == 0 hello = i end end julia> hello 9

Similar to Loop Variable, the variables declared inside a loop won’t exist once the loop is finished.

julia> for x in 1:10 y = x^2 println("$(x) squared is $(y)") end

1 squared is 1 2 squared is 4 3 squared is 9 4 squared is 16 5 squared is 25 6 squared is 36 7 squared is 49 8 squared is 64 9 squared is 81 10 squared is 100 julia> y ERROR: UndefVarError: y not defined

The Continue statement is used to skip the rest of the code inside the loop and start the loop again with the next value. It is mostly used in the case when on a particular iteration you want to skip to the next value.

julia> for x in 1:10 if x % 4 == 0 continue end println(x) end

1 2 3 5 6 7 9 10

Generating and collecting items something like [n for n in 1:5] is called array comprehensions. It is sometimes called list comprehensions too.

julia> [X^2 for X in 1:5] 5-element Array{Int64,1}: 1 4 9 16 25

We can also specify the types of elements we want to generate −

julia> Complex[X^2 for X in 1:5] 5-element Array{Complex,1}: 1 + 0im 4 + 0im 9 + 0im 16 + 0im 25 + 0im

Sometimes we would like to go through an array element by element while keeping track of the index number of every element of that array. Julia has enumerate() function for this task. This function gives us an iterable version of something. This function will produce the index number as well as the value at each index number.

julia> arr = rand(0:9, 4, 4) 4×4 Array{Int64,2}: 7 6 5 8 8 6 9 4 6 3 0 7 2 3 2 4 julia> [x for x in enumerate(arr)] 4×4 Array{Tuple{Int64,Int64},2}: (1, 7) (5, 6) (9, 5) (13, 8) (2, 8) (6, 6) (10, 9) (14, 4) (3, 6) (7, 3) (11, 0) (15, 7) (4, 2) (8, 3) (12, 2) (16, 4)

Using the **zip()** function, you can work through two or more arrays at the same time by taking the 1^{st} element of each array first and then the 2^{nd} one and so on.

Following example demonstrates the usage of **zip()** function −

julia> for x in zip(0:10, 100:110, 200:210) println(x) end (0, 100, 200) (1, 101, 201) (2, 102, 202) (3, 103, 203) (4, 104, 204) (5, 105, 205) (6, 106, 206) (7, 107, 207) (8, 108, 208) (9, 109, 209) (10, 110, 210)

Julia also handle the issue of different size arrays as follows −

julia> for x in zip(0:15, 100:110, 200:210) println(x) end (0, 100, 200) (1, 101, 201) (2, 102, 202) (3, 103, 203) (4, 104, 204) (5, 105, 205) (6, 106, 206) (7, 107, 207) (8, 108, 208) (9, 109, 209) (10, 110, 210) julia> for x in zip(0:10, 100:115, 200:210) println(x) end (0, 100, 200) (1, 101, 201) (2, 102, 202) (3, 103, 203) (4, 104, 204) (5, 105, 205) (6, 106, 206) (7, 107, 207) (8, 108, 208) (9, 109, 209) (10, 110, 210)

Nest a loop inside another one can be done with the help of using a comma (;) only. You do not need to duplicate the **for** and **end** keywords.

julia> for n in 1:5, m in 1:5 @show (n, m) end (n, m) = (1, 1) (n, m) = (1, 2) (n, m) = (1, 3) (n, m) = (1, 4) (n, m) = (1, 5) (n, m) = (2, 1) (n, m) = (2, 2) (n, m) = (2, 3) (n, m) = (2, 4) (n, m) = (2, 5) (n, m) = (3, 1) (n, m) = (3, 2) (n, m) = (3, 3) (n, m) = (3, 4) (n, m) = (3, 5) (n, m) = (4, 1) (n, m) = (4, 2) (n, m) = (4, 3) (n, m) = (4, 4) (n, m) = (4, 5) (n, m) = (5, 1) (n, m) = (5, 2) (n, m) = (5, 3) (n, m) = (5, 4) (n, m) = (5, 5)

We use while loops to repeat some expressions while a condition is true. The construction is like **while…end**.

julia> n = 0 0 julia> while n < 10 println(n) global n += 1 end 0 1 2 3 4 5 6 7 8 9

Exceptions or try…catch construction is used to write the code that checks for the errors and handles them elegantly. The catch phrase handles the problems that occur in the code. It allows the program to continue rather than grind to a halt.

julia> str = "string"; julia> try str[1] = "p" catch e println("the code caught an error: $e") println("but we can easily continue with execution...") end the code caught an error: MethodError(setindex!, ("string", "p", 1), 0x0000000000006cba) but we can easily continue with execution...

Do block is another syntax form similar to list comprehensions. It starts at the end and work towards beginning.

julia> Prime_numbers = [1,2,3,5,7,11,13,17,19,23]; julia> findall(x -> isequal(19, x), Prime_numbers) 1-element Array{Int64,1}: 9

As we can see from the above code that the first argument of the find() function. It operates on the second. But with a do block we can put the function in a do…end block construction.

julia> findall(Prime_numbers) do x isequal(x, 19) end 1-element Array{Int64,1}: 9

Advertisements