Auto-evaluation

We have included in this page a series of quizzes to help reinforce your learning. These quizzes are designed not only to test your understanding but also to provide you with an opportunity for self-reflection. After each quiz, take a moment to review your answers, reflect on what you’ve learned, and identify areas where you may need further clarification. Do not hesitate to reach out to your lecturer if any questions come up.

Core Syntax

Question 1. Which of the following defines a variable x with value 10 in Julia?

Select an item

int x = 10

x := 10

let x = 10

x = 10

Question 2. Which keyword is used to define a function in Julia?

Select an item

func

lambda

def

function

Question 3. Which symbol is used for element-wise operations in Julia (e.g., squaring each element of a vector)?

Select an item

*

:

->

.

Question 4. What is the output of this code?

a = [1, 2, 3]
b = a
b[1] = 10
println(a)

Select an item

Error.

[1, 2, 3]

[10, 2, 3]

[1, 10, 3]

Question 5. What does the end keyword do in Julia?

Select an item

Closes a block of code like if, for, or function.

Ends a program.

Skips to the next iteration.

Marks a breakpoint.

Question 6. Which expression returns the number of elements in a vector v?

Select an item

dim(v)

count(v)

size(v)

length(v)

Question 7. What does === do in Julia?

Select an item

Checks if two expressions are numerically equal.

Checks if two expressions refer to the exact same object in memory.

Compares string equality.

Performs type conversion.

Question 8. How do you stop a loop early in Julia?

Select an item

break

stop

exit

return

Question 9. How do you skip the current iteration of a loop in Julia?

Select an item

skip

pass

next

continue

Question 10. Which of the following is a valid for loop in Julia?

Select an item

for i = 1 to 10

for i in 1:10

for (i = 1; i <= 10; i++)

foreach i in 1:10

Type Hierarchies

Question 1. What is the purpose of an abstract type in Julia?

Select an item

It is used for type annotations in functions.

It provides a blueprint for organizing related types but cannot be instantiated.

It can be instantiated and used directly.

It defines a concrete implementation for other types.

Question 2. Which of the following types is a concrete type?

Select an item

Int64

AbstractFloat

Number

Real

Question 3. What does the isconcretetype function return for AbstractFloat?

Select an item

true

null

false

Error: Undefined type

Question 4. What will the following code return?

typeof(42)

Select an item

Int64

Real

Integer

Number

Question 5. What is the purpose of the isa operator in Julia?

Select an item

To check if a variable's value matches a specific type.

To check if a type is concrete.

To check if a variable is a subtype of Any.

To check if a variable is an instance of a specific type or any of its subtypes.

Question 6. What will be the result of the following code?

Int64 <: Real

Select an item

Error: Type mismatch

true for Float64 but not for Int64

true

false

Question 7. What will the following code return?

isconcretetype(Int64)
isconcretetype(AbstractFloat)

Select an item

false for both types

false for both types if using a different syntax

true for AbstractFloat and false for Int64

true for Int64 and false for AbstractFloat

Question 8. What does the <: operator check in Julia?

Select an item

If a type can be instantiated.

If a type is abstract.

If one type is a subtype of another.

If two types are exactly the same.

Question 9. What is the result of the following code?

subtypes(Real)

Select an item

Returns an error because Real is abstract.

Returns Any as the only subtype of Real.

Shows Real as a parent type with no subtypes.

Returns a list of all types that are subtypes of Real.

Question 10. What does the supertype function return for Float64?

supertype(Float64)

Select an item

Int

Real

AbstractFloat

Number

Type Conversion and Promotion

Question 1. What does the convert function do in Julia?

Select an item

It converts numbers to strings.

It automatically promotes values to a common type.

It converts a value from one type to another, if possible.

It changes a value to a boolean type.

Question 2. What is the output of the following code?

println(round(Int, 3.14))   # Rounds 3.14 to the nearest integer, output: 3
println(floor(Int, 3.14))   # Floors 3.14 to the nearest integer, output: 3
println(convert(Float64, 5))  # Converts Int to Float64, output: 5.0
println(string(123))         # Converts Int to String, output: "123"

Select an item

3, 3, 5.0, 123

5.0, 3, 5, '123'

3, 3.14, 5, '123'

3, 3, 5.0, '123'

Question 3. What happens when an integer is assigned to a Float64 variable in Julia?

y::Float64 = 10  # The integer 10 is automatically converted to 10.0 (Float64)
println(y)       # Output: 10.0

Select an item

Julia throws a type error because of the type mismatch.

The variable y will be set to the integer value of 10.

Julia automatically converts the integer to a Float64.

The conversion needs to be done explicitly using convert.

Question 4. What does the promote function do in Julia?

a, b = promote(3, 4.5)  # Promotes both values to Float64
println(a)              # Output: 3.0
println(b)              # Output: 4.5
println(typeof(a))      # Output: Float64
println(typeof(b))      # Output: Float64

Select an item

It checks if two values have the same type.

It converts values to strings for display.

It promotes two values to a common type for an operation.

It converts both values to integers.

Question 5. What will happen if we try to add an Int and a String in Julia?

println(3 + "Hello")  # Attempting to add Int and String

Select an item

Julia will automatically convert both to a common type.

It will concatenate the string and the number.

It will throw a type error.

It will promote the number to a string.

Special Types

Question 1. What does the Nothing type represent in Julia?

Select an item

It is a special type for numeric values.

It is a placeholder for missing data.

It represents the absence of a meaningful value.

It is used for undefined variables.

Question 2. What is the result of calling the following function in Julia?

# Example of a function that returns `Nothing`
function print_message(msg::String)
    println(msg)
    return nothing  # Explicitly returns `nothing`
end

result = print_message("Hello!")
println(result === nothing)  # Output: true

Select an item

nothing is returned but the output is false.

The function throws an error because nothing cannot be returned.

The function returns a string 'nothing'.

nothing is returned and the output is true.

Question 3. What is the advantage of using Any as a type in Julia?

# Example of using `Any` as a type
function describe(value::Any)
    println("Value: ", value)
    println("Type: ", typeof(value))
end

describe(42)         # Works with Int
describe("Hello")    # Works with String
describe(3.14)       # Works with Float64

Select an item

It increases performance by restricting the type of variable.

It allows variables to hold any type, making the code flexible.

It makes type inference more precise.

It prevents runtime errors related to data types.

Question 4. What does the following code do in Julia?

data = [1, 2, missing, 4, 5]
for item in data
    if item === missing
        println("Missing data detected.")
    else
        println("Value: ", item)
    end
end

Select an item

It throws an error when encountering missing data.

It checks for missing values and prints a message for each.

It sums all the values and skips missing ones.

It replaces missing data with a default value.

Question 5. What is the purpose of the skipmissing function in Julia?

using Statistics

# Example array with missing values
data = [1, 2, missing, 4, 5, missing, 7]

# Summing values while skipping missing entries
sum_no_missing = sum(skipmissing(data))
println("Sum without missing values: ", sum_no_missing)  # Output: 19

# Calculating the mean while skipping missing values
mean_no_missing = mean(skipmissing(data))
println("Mean without missing values: ", mean_no_missing)  # Output: 3.8

Select an item

It prints out the number of missing values.

It raises an error if missing values are encountered.

It replaces missing values with 0.

It creates an iterator that skips missing values during computations.

Question 6. What is the main use of the Missing type in Julia?

# Example of using `missing` in an array
data = [1, 2, missing, 4, 5]

# Check for missing values in the array
for item in data
    if item === missing
        println("Missing data detected.")
    else
        println("Value: ", item)
    end
end

Select an item

To represent missing or unknown data in a collection.

To hold any type of data including missing entries.

To prevent errors when dealing with Nothing.

To represent variables with no value assigned.

Union Types

Question 1. What is a Union type in Julia?

Select an item

A type that allows a variable to accept multiple types.

A type that can only accept floating-point numbers.

A built-in function for type conversion.

A type that restricts a variable to only one type.

Question 2. What is the output of the following code?

function process_number(x::Union{Int, Float64})
    println("The input is: ", x)
end

process_number(5)       # Works with an Int
process_number(3.14)    # Works with a Float64

Select an item

The input is: 5, The input is: 3

The input is: 5, The input is: 3.14

The input is: 3.14, The input is: 5

The input is: 5, The input is: 3.0

Question 3. Which of the following scenarios would benefit from using a Union type?

# Example using Union to handle multiple types in a function
function add_one(x::Union{Int, Float64})
    return x + 1
end

println(add_one(3))     # Output: 4 (Int)
println(add_one(2.5))   # Output: 3.5 (Float64)

Select an item

When there is a strict requirement to accept a specific type.

When a function accepts only integers.

When a function needs to accept both integers and floating-point numbers.

When a function is only designed to accept floating-point numbers.

Question 4. What happens when a value of a type not listed in the Union is passed to a function?

function process_number(x::Union{Int, Float64})
    println("The input is: ", x)
end

process_number("Hello")  # Trying to pass a String

Select an item

It will throw a MethodError because String is not part of the Union.

It will automatically convert the string to an integer.

It will work without issue because String is compatible with Union.

It will throw a TypeError due to the type mismatch.

Question 5. How does the add_one function handle both Int and Float64 types?

function add_one(x::Union{Int, Float64})
    return x + 1
end

println(add_one(3))     # Output: 4 (Int)
println(add_one(2.5))   # Output: 3.5 (Float64)

Select an item

It works for both types without needing separate methods.

It requires type checking before execution.

It only works for Float64 types.

It throws an error for Int but works for Float64.

Type Annotations and Declarations

Question 1. What is the primary purpose of type annotations in Julia?

Select an item

To prevent errors from occurring in the code.

To specify the exact memory address of a variable.

To make code run faster by skipping type checks.

To provide clarity in the code and enable optimizations by the compiler.

Question 2. Which of the following correctly applies a type annotation to a variable?

Select an item

a = 10::Int

a::Int = 10

a:Int = 10

Int::a = 10

Question 3. What will happen if the following code is executed?

function add(a::Int, b::Int)
    return a + b
end

add(3, "4")

Select an item

It will throw a syntax error.

It will throw a type error because "4" is a String, not an Int.

It will ignore the type annotation and return 7.

It will convert "4" to an Int and return 7.

Question 4. In Julia, what will the following code output?

function multiply(a::Int, b::Int)::Int
    return a * b
end
multiply(3, 4)

Select an item

12.0

Error: Incorrect type

Nothing

12

Parametric Types

Question 1. What is a parametric type in Julia?

Select an item

A type that can only work with abstract types.

A type that is defined for a specific data type.

A type that can work with multiple data types, specified by parameters.

A type that doesn't require any parameters.

Question 2. What is the role of T and S in the Pair struct example?

struct Pair{T, S}
    first::T
    second::S
end

pair1 = Pair(1, "apple")  # Pair of Int and String
pair2 = Pair(3.14, true)  # Pair of Float64 and Bool

Select an item

T and S define the data types of the first and second elements of the pair.

T defines the data type of both elements in the pair.

T is used for the first element, and S is used for the second element.

T and S are unused in this case, they are placeholders.

Question 3. What happens when you instantiate Pair(1, 'apple') in the provided code?

pair1 = Pair(1, "apple")  # Pair of Int and String

Select an item

It will throw an error because Int and String can't be combined.

It will create a pair with Int64 and String.

It will create a pair with an Int and a String.

It will cause a runtime error because the types don't match.

Question 4. What is the benefit of using parametric types like AbstractContainer{T}?

abstract type AbstractContainer{T} end

struct VectorContainer{T} <: AbstractContainer{T}
    data::Vector{T}
end

struct SetContainer{T} <: AbstractContainer{T}
    data::Set{T}
end

Select an item

It allows you to create types that can handle any type of data, with type safety.

It makes the code more complex and harder to maintain.

It makes the code less flexible and more specific.

It allows you to specify concrete types directly in the struct.

Question 5. What does the print_container_info function do?

function print_container_info(container::AbstractContainer{T}) where T
    println("Container holds values of type: ", T)
end

Select an item

It returns the type of the container.

It prints the type of the container.

It prints the number of elements in the container.

It prints the values inside the container.

Question 6. What is the purpose of AbstractContainer{T} in the code example?

abstract type AbstractContainer{T} end

Select an item

It defines a container for a specific type of data.

It defines a concrete container type.

It defines an abstract type that can be used to create containers for any data type T.

It restricts containers to hold only numeric types.

Question 7. What would be the output of print_container_info(vec) if vec is VectorContainer([1, 2, 3])?

vec = VectorContainer([1, 2, 3])

Select an item

It will print the type AbstractContainer{Int}.

It will print the type Vector{Int}.

It will throw an error because VectorContainer is not defined.

It will print the values inside the container.

Question 8. How does using parametric types help with code reusability?

Select an item

It reduces the need to define separate functions for different data types.

It forces you to create new types for every use case.

It makes the code less reusable.

It requires more boilerplate code.

Errors and Exception Handling

Question 1. Which error type is raised when an index is out of bounds in an array?

Select an item

DivisionByZeroError

IOError

BoundsError

ArgumentError

Question 2. What does the following code do in Julia?

function divide(a, b)
    if b == 0
        throw(DivideError())
    end
    return a / b
end

Select an item

It raises an ArgumentError when a or b is invalid.

It throws a BoundsError if a or b are not numbers.

It raises a DivideError when b equals 0.

It performs division and returns the result.

Question 3. What happens when the following try/catch block is executed?

try
    println(divide(10, 0))  # Will raise an error
catch e
    println("Error: ", e)  # Handles the error
end

Select an item

The program prints the result of the division.

The program throws an error and stops execution.

The error is caught and a custom error message is printed.

The program silently ignores the error.

Question 4. What is the purpose of the finally block in Julia’s exception handling?

Select an item

To perform the main logic of the program.

To ensure that cleanup code runs regardless of whether an error occurs.

To catch all errors and handle them.

To rethrow any errors that are caught.

Question 5. What is the output of the following code?

function safe_file_read(filename::String)
    file = nothing
    try
        file = open(filename, "r")
        data = read(file, String)
        return data
    catch e
        println("An error occurred: ", e)
    finally
        if file !== nothing
            close(file)
            println("File closed.")
        end
    end
end

# Test with a valid file
println(safe_file_read("example.txt"))

# Test with an invalid file
println(safe_file_read("nonexistent.txt"))

Select an item

The program tries to read a file, catches errors, and always closes the file.

The program raises an error and does not close the file.

The program prints data from the file and closes it.

The program prints the error but skips file closing.

Question 6. Which of the following is an appropriate use case for the finally block?

Select an item

To handle errors and return a value from the finally block.

To catch all exceptions without handling them.

Ensuring a file is closed after reading, regardless of errors.

To prevent specific types of errors from being raised.

Performance

Question 1. What does it mean for a function in Julia to be type stable?

Select an item

It always avoids recursion.

It always returns an Int64.

It never allocates memory.

The return type can be predicted at compile time from the input types.

Question 2. Which Julia macro is commonly used to check for type stability?

Select an item

@time

@code_warntype

@show

@inbounds

Question 3. Which of the following best describes a type-unstable function?

Select an item

A function that runs slower than expected.

A function where the compiler cannot infer a concrete return type.

A function that returns multiple values.

A function that allocates memory unnecessarily.

Question 4. Consider the function:

function g(x)
    return x > 10 ? 10 : "small"
end

Select an item

The function is type stable.

The function is type unstable.

The function will always error.

The function is recursive.

Question 5. In Julia, which type causes the biggest problems for type inference when used as a return type?

Select an item

Int64

Any

Bool

Float64

Question 6. Which of the following is volatile (non permanent) memory?

Select an item

Hard disk.

Flash drive.

RAM.

SSD.

Question 7. Which component temporarily stores instructions and data for quick access by the CPU?

Select an item

Cache.

GPU.

ROM.

Hard disk.

Question 8. he basic unit of data in computer hardware is:

Select an item

Word.

Byte.

Bit.

Nibble.