Comparison and Logical Operators

To develop effective programs, simply performing calculations is often insufficient. To create programs that can react to different situations and make choices, methods for comparing values and combining logical conditions are needed. Comparison and logical operators are thus essential. They allow Julia programs to evaluate conditions, ultimately determining how a program behaves.

Making Comparisons

Comparison operators, also known as relational operators, are used to compare two values. The result of a comparison is always a Boolean value: either true or false. These operators are fundamental for decision-making in code.

Here are the standard comparison operators available in Julia:

• == (Equal to): Returns true if the values on either side are equal.

  5 == 5    # true
  5 == 3    # false
  "hello" == "hello" # true
  

• != (Not equal to): Returns true if the values are not equal. This can also be written as ≠ (you can type \ne followed by Tab in the Julia REPL or many Julia-aware editors).

  5 != 3    # true
  5 != 5    # false
  "julia" != "python" # true
  

• < (Less than): Returns true if the value on the left is less than the value on the right.

  3 < 5     # true
  5 < 3     # false
  

• > (Greater than): Returns true if the value on the left is greater than the value on the right.

  10 > 5    # true
  5 > 10    # false
  

• <= (Less than or equal to): Returns true if the left value is less than or equal to the right value. Also ≤ (type \le then Tab).

  4 <= 5    # true
  5 <= 5    # true
  6 <= 5    # false
  

• >= (Greater than or equal to): Returns true if the left value is greater than or equal to the right value. Also ≥ (type \ge then Tab).

  7 >= 5    # true
  5 >= 5    # true
  3 >= 5    # false
  

You can use these operators with various data types, such as numbers and strings. When comparing numbers of different types (e.g., an integer and a floating-point number), Julia will often promote them to a common type before comparison.

x = 10
y = 5.0

println(x > y)      # Output: true
println(x == 10.0)  # Output: true
println(y < 3)      # Output: false

Combining Conditions with Logical Operators

Often, a single comparison isn't enough. You might need to check if multiple conditions are true, or if at least one of several conditions is met. Logical operators allow you to combine or modify Boolean values (true or false).

Julia provides three main logical operators:

• && (Logical AND): Returns true if, and only if, both operands are true.
• || (Logical OR): Returns true if at least one of the operands is true.
• ! (Logical NOT): Reverses the Boolean value of its operand. If the operand is true, it returns false, and if false, it returns true.

Let's look at their behavior, often summarized in what are called truth tables:

Logical AND (&&)

Operand A	Operand B	A && B
true	true	true
true	false	false
false	true	false
false	false	false

Logical OR (||)

| Operand A | Operand B | A || B | | :-------- | :-------- | :------- | | true | true | true | | true | false | true | | false | true | true | | false | false | false |

Logical NOT (!)

Operand A	!A
true	false
false	true

Here are some examples in Julia:

is_sunny = true
is_warm = false

# Logical AND
can_go_to_beach = is_sunny && is_warm
println("Can go to the beach? $can_go_to_beach")  # Output: Can go to the beach? false

# Logical OR
is_good_weather_overall = is_sunny || is_warm
println("Good weather overall? $is_good_weather_overall") # Output: Good weather overall? true

# Logical NOT
is_not_sunny = !is_sunny
println("Is it not sunny? $is_not_sunny")        # Output: Is it not sunny? false

You can visualize how logical operators combine conditions. For instance, if you need two conditions to be true for an action to occur, both must evaluate to true when combined with an AND operator.

Two conditions, is_registered and has_paid_fee, are combined using a logical AND. If both are true, the outcome is true.

Short-Circuit Evaluation: Efficient Logic

Julia's logical && and || operators exhibit a behavior called "short-circuit evaluation." This is an important efficiency feature and can also be used to prevent errors.

• For A && B: If A evaluates to false, the entire expression must be false, so B is never evaluated.
• For A || B: If A evaluates to true, the entire expression must be true, so B is never evaluated.

Consider this example:

function is_valid_user(id::Int)
    println("Checking user ID: $id") # This line helps us see if the function runs
    return id > 0 && id < 1000       # A simple validity check
end

user_id = 0
access_granted = false && is_valid_user(user_id)
# "Checking user ID: 0" will NOT be printed because `false && ...` short-circuits.
println("Access granted (first attempt): $access_granted") # Output: false

user_name = "admin"
is_admin = true
has_special_privileges = is_admin || is_valid_user(100)
# "Checking user ID: 100" will NOT be printed because `true || ...` short-circuits.
println("Has special privileges: $has_special_privileges") # Output: true

# Example where the second part IS evaluated
can_login = (user_name == "admin") && is_valid_user(500)
# "Checking user ID: 500" WILL be printed because the first part is true.
println("Can login: $can_login") # Output: true (assuming is_valid_user(500) returns true)

Short-circuiting is useful, for example, when checking an object for a property only if the object itself is not nothing, preventing an error.

Combining Operators and Using Parentheses

You can create complex logical expressions by combining multiple comparison and logical operators.

age = 25
has_license = true
is_student = false

# Can rent a car if age is 25 or older AND has a license
can_rent_car = (age >= 25) && has_license
println("Can rent car: $can_rent_car") # Output: true

# Eligible for discount if a student OR younger than 18 (and implicitly not needing a license for this discount)
eligible_for_discount = is_student || (age < 18)
println("Eligible for discount: $eligible_for_discount") # Output: false

When expressions become complex, the order of evaluation matters. Logical operators have a defined precedence (! is highest, then &&, then ||). However, relying on implicit precedence can make code harder to read and debug.

It's highly recommended to use parentheses () to explicitly group parts of your expressions. This makes your intentions clear and ensures the logic is evaluated as you expect.

For example, instead of a && b || c, write (a && b) || c or a && (b || c) depending on your intended logic.

A Quick Note: Equality (==) vs. Assignment (=)

A common point of confusion for new programmers is the difference between the equality operator == and the assignment operator =.

• = (single equals sign) is used for assignment. It assigns the value on the right to the variable on the left.

  my_variable = 10  # Assigns the value 10 to my_variable
  

• == (double equals sign) is used for comparison. It checks if two values are equal and returns true or false.

  my_variable == 10 # Checks if my_variable is equal to 10; returns true
  my_variable == 5  # Checks if my_variable is equal to 5; returns false
  

Mixing these up can lead to errors that are sometimes tricky to spot, so always double-check you're using the correct operator for your intended purpose.

Comparison and logical operators are the building blocks for creating programs that can make decisions. The true or false values they produce are precisely what control flow structures, such as if-elseif-else statements (which you'll learn about next), use to determine which blocks of code to execute. Mastering these operators is a significant step towards writing more dynamic and intelligent Julia programs.