Chapter 2: Conditions and Control Flow

In the example of an ATM money withdrawal algorithm in the previous chapter we have seen steps, where we would jump to other steps depending on a specific condition.

Insert your debit card.
Choose the withdraw option.
If desired, enter a specific value, go to 5.
Select one of the pre-set values.
If desired, choose the denomination.
Enter your PIN, if correct go to 8.
Go to 6.
Take your card and money.

However, we have not yet learned how to do it in our programs, in the simple examples that we have written until now, we have executed every step sequentially.
In this chapter we will talk about conditional execution of certains parts of a program.

Truth Values
Comparison Operators
Boolean Algebra
Control Structures
If Statement
Loop Statement
Waiting for User Input

Truth Values

Also when we were discussing values and data types we have already seen an examplary use of a truth value.
Truth or logical values are used in programming to evaluate a specific condition and determine whether it is true or false.
Therefore, there are only two possible truth values: true and false.

program booleanValues import IO main variable t : boolean variable f : boolean t := true f := false IO.writeBoolean(t) IO.writeLine() IO.writeBoolean(f) IO.writeLine() endmain

Comparison Operators

Now that we have defined our logical values, we can use them to actually check whether some conditions are true or not.
To do this, we can use conditional operators:

= : equal, applicable to any type
/= : not equal, applicable to any type
< : lesser than, applicable to numerical types
> : greater than, applicable to numerical types
<= : lesser than or equal, applicable to numerical types
>= : greater than or equal, applicable to numerical types

For example, 2 + 2 = 4 will yield true while 2 + 2 /= 4 will yield false.

program comparisonOperators import IO main IO.writeString("2 = 2 ---> ") IO.writeBoolean(2 = 2) IO.writeLine() // true IO.writeString("2 = 5 ---> ") IO.writeBoolean(2 = 5) IO.writeLine() // false IO.writeString("2 /= 5 ---> ") IO.writeBoolean(2 /= 5) IO.writeLine() // true IO.writeString("2 < 5 ---> ") IO.writeBoolean(2 < 5) IO.writeLine() // true IO.writeString("2 > 5 ---> ") IO.writeBoolean(2 > 5) IO.writeLine() // false endmain

Boolean Algebra

Sometimes we have to check more than one condition, for example we want to check if two numbers a and b are equal and are greater than 0.
To do this, we have to define at least two conditions: a = b and a > 0.
Right now, we have two separate expressions, however both must true in our scenario, we have to combine them using a logical operator and: a = b and a > 0.
Now we have one logical expression, which is only then true, if both subexpressions are also true.

To sum it up, we have three logical operators, ordered according to their precedence:

not : negates the expression
and : the expression is true if both sides of it are true, false otherwise
or : the expression is true if at least one side is true, false only when both sides are false

AND	true	false
true	true	false
false	false	false

OR	true	false
true	true	true
false	true	false

The precedence is important since it determines in which sequence the operators are evaluated.
Similar to how multiplication or division is evaluated before addition or subtraction, the not operator is always applied first.
Afterwards, the operator and is evaluated before the operator or.
For example, in the expression x < 0 and x = -5 or x > 0 and x = 5 we would first evaluate the expressions x < 0 and x = -5 and x > 0 and x = 5.
Once done, we would compare the results with the or operator

To get a feeling for the boolean algebra, copy the example below and play around with it assigning different values to x or defining new expressions.

program booleanOperators import IO import Lists main variable x : integer x := 5 IO.writeString("0 < x < 10 ---> ") IO.writeBoolean(x > 0 and x < 10) IO.writeLine() IO.writeString("x = 0 or x = 5 ---> ") IO.writeBoolean(x = 0 or x = 5) IO.writeLine() IO.writeString("x is not less than 5 ---> ") IO.writeBoolean(not (x < 5)) IO.writeLine() IO.writeLine() IO.writeBoolean(x < 0 and x = -5 or x > 0 and x = 5) IO.writeLine() endmain

Control Structures

As already mentioned at the beginning of this chapter, until now we were executing our programs in a purely sequential manner.
We have also said that, depending on specific conditions, which we now know how to define using logical values and boolean algebra, we can skip or repeat certain steps.
Thus we have three concepts to define the flow of our program:

Sequence - simple sequential execution of steps:

Declare integer variable x
Assign 5 to x
Print value of x
End of the algorithm

Conditional branching - execution or skipping certain steps depending on a condition:

If value of x is less than 0, go to 3
Compute the root of x and print the result
End of the algorithm

Repetition - repeating certain steps:

Increment the value of x by 1
Print value of x
Go to 1
End of the algorithm

As you can see, in the last example we would have an endless repetition, i.e. we would eternally increment our x and print its value never reaching the end.
To prevent such situations, we have to define termination conditions for our repetitions:

Increment the value of x by 1
Print value of x
If value of x equals 10, goto 5
Go to 1
End of the algorithm

This imprived version of our algorithm would repeat the required steps until x reaches the value of 10, in which case the algorithm will terminate.

It should be noted that modern high level programming languages no longer use a goto instruction, instead they rely on conditional statements, loops and recursion.
We will handle recursion in the last chapter, for now, let us concentrate on conditional statements and loops.

If Statement

If statements allow us to check a condition and execute certain lines of code is this condition is met:

program ifStatement1 import IO main variable x : integer x := 5 if x = 5 then // the execution condition is checked here IO.writeString("x is equal 5") // code that is executed if the condition is true endif endmain

The line of code between then and endif will only be executed in the value of x is 5, which is true in this case.

If statements also allow us to define several branches, in fact we can define as many branches as we like.
We can also nest our if statements, allowing us to implement more complex branching.

program ifStatement2 import IO main variable x : integer x := -5 if x >= 0 and x < 10 then IO.writeString("x is in range [0 .. 10[") IO.writeLine() elseif x < 0 then IO.writeString("x is negative") IO.writeLine() if x > -10 then IO.writeString("x is in range ]-10 .. 0[") IO.writeLine() endif else IO.writeString("x is greater or equal 10") IO.writeLine() endif endmain

By now we can start implementing a simple logic for our ATM money withdrawal algorithm.
We want a simple program where we can define our account balance, enter the amount of money to withdraw and check if we can actually withdraw that amount.
If we can, the account balance should be reduced by the respective amount.

program simpleATM import IO main variable balance : integer balance := 500 IO.writeString("Please enter the amount of money to withdraw: ") variable amount : integer amount := IO.readInteger() if balance >= amount then balance := balance - amount IO.writeString("Withdrawal successful, current balance: ") IO.writeInteger(balance) else IO.writeString("Withdrawal not possible, current balance: ") IO.writeInteger(balance) endif endmain

Loop Statement

The final control structure is repetition.
This can be achieven either via recursion, which we will discuss in the last chapter, or by using loops.
Most modern programming languages that support loops offer various kinds of loops which allow to specify their own termination conditions.
MuLE, on the other hand, offers a single loop construct, which is by definition infinite.
That means, that we have to use an if statement to check the termination condition.

The following example demonstrates a simple loop:

program loopStatement import IO main variable i : integer i := 0 loop if i = 4 then exit endif IO.writeString("i: ") IO.writeInteger(i) IO.writeLine() i := i + 1 endloop endmain

The produced output is:

i: 0 i: 1 i: 2 i: 3

Waiting for User Input

In the previous example we have demonstrated a loop, which runs a set amount of time.
However, sometimes we do not know how often we want to execute certain lines of code.
For example, if we want to allow our algorithm to wait for user input and allow different actions depending on that input.
We can do that with a loop, which may run for a potentially infinite number of times.

program userInput import IO main loop IO.writeString("Loop executed, do you want to run it again?\n") IO.writeString("Enter n or N to terminate.") variable input : string input := IO.readString() if input = "n" or input = "N" then exit endif endloop endmain

The program will terminate only if we enter n or N.

Let us now expand our previous simple ATM example.
We want to display our current account balance, and offer three options: terminate the program, transfer money to the account or withdraw money.

program userInputATM import IO import Strings main variable balance : rational loop IO.writeString("Your current balance: " & Strings.rationalToString(balance) & "\n") IO.writeString("Enter 1 to transfer money to you account.\n") IO.writeString("Enter 2 to withdraw money from you account.\n") IO.writeString("Enter 0 to terminate the program.\n") variable input : integer input := IO.readInteger() if input = 0 then exit elseif input = 1 then IO.writeString("Enter the amount of money to transfer: ") variable amount : rational amount := IO.readRational() balance := balance + amount elseif input = 2 then IO.writeString("Enter the amount of money to withdraw: ") variable amount : rational amount := IO.readRational() if balance - amount < 0 then IO.writeString("Withdrawal not possible.\n") else balance := balance - amount endif else IO.writeString("Unknown command!\n") endif endloop endmain

The user interaction could look like this:

Your current balance: 0.0 Enter 1 to transfer money to you account. Enter 2 to withdraw money from you account. Enter 0 to terminate the program. 1 Enter the amount of money to transfer: 1000 Your current balance: 1000.0 Enter 1 to transfer money to you account. Enter 2 to withdraw money from you account. Enter 0 to terminate the program. 2 Enter the amount of money to withdraw: 500 Your current balance: 500.0 Enter 1 to transfer money to you account. Enter 2 to withdraw money from you account. Enter 0 to terminate the program. 2 Enter the amount of money to withdraw: 900 Withdrawal not possible. Your current balance: 500.0 Enter 1 to transfer money to you account. Enter 2 to withdraw money from you account. Enter 0 to terminate the program. 9 Unknown command! Your current balance: 500.0 Enter 1 to transfer money to you account. Enter 2 to withdraw money from you account. Enter 0 to terminate the program. 0