## Chapter 2 – Decisions ### Making decisions All the programs we have seen so far have been predictable; they went straight through the instructions, then went back to the beginning again. This is not very useful. In practice the computer would be expected to make decisions and act accordingly. There are three ways *NextBASIC* helps you make decisions: The first is by using the **IF** keyword in a short, medium and long format, the second by using the **ON** *case selection* keyword and the third is by using the *select operator* **?** (question mark). ### Using IF… to make decisions The short and medium form of **IF** are as follows: **IF** *condition* **THEN** *action* [**ELSE** *alternative action*] Clear the previous program from memory by using **NEW** and type in and run the following example: ``` 10 REM Guess the number 20 INPUT "Enter the number to guess", a: CLS 30 INPUT "Guess the number", b 40 IF b=a THEN PRINT "That is correct": STOP 50 IF ba THEN PRINT "That is too big, try again" 70 GO TO 30 ``` You can see that in its simplest form an **IF** statement is: **IF** *condition* **THEN** *action* where *action* stands for a sequence of commands, separated by colons in the usual way. The condition is something that is going to be worked out as either true or false; if it comes out as true then the statements in the rest of the line after **THEN** are executed, but otherwise they are skipped over, and the program executes the next instruction. The simplest conditions compare two numbers or two strings: they can test whether two numbers are equal or whether one is bigger than the other; and they can test whether two strings are equal, or (roughly) one comes before the other in alphabetical order. They use the relations =, <, >, <=, >= and <>. Additionally we can use **NOT**, **AND**, **OR**, ! (bitwise NOT), **|** (bitwise OR), **&** (bitwise AND), ^**|** (bitwise XOR) all of which produce a *true* (**1**) or *false* (**0**) result = means *equals*. Although it is the same symbol as the = in a **LET** command, it is used in quite a different sense. < means *is less than* so that: **1 < 2**\ **-2 <-1**\ **-3 < 1** are all *true*, but: **1 < 0**\ **0 <-2** are *false*. > means *is greater than*, and is just like < but the other way round. You can remember which is which, because the thin end points to the number that is supposed to be smaller. <= means *is less than or equal to,* so that it is like < except that it is true even if the two numbers are equal: thus **2<=2** is true, but **2<2** is false. >= means *is greater than or equal to* and is similarly like >. <> means *is not equal to*, the opposite in meaning to =. The remaining operators are explained in length in *Chapter 6 – Expressions*. Mathematicians usually write <=, >= and <> as ≤, ≥ and ≠. They also write things like **2<3<4** to mean **2<3** and **3<4**, but this is not possible in *NextBASIC*. Line 40 compares **a** and **b**. If they are equal then the program is halted by the **STOP** command. The report at the bottom of the screen **9 STOP, statement, 30:3** shows that the third statement, or command, in line 30 caused the program to halt, i.e. **STOP**. Line 50 determines whether **b** is less than **a**, and line 60 whether **b** is greater than **a**. If one of these conditions is true then the appropriate comment is printed, and the program works its way to line 70 which tells the computer to go back to line 30 and start all over again. The **CLS** command in line 20 clears the screen to stop the other person seeing what you put in. Note: in some versions of BASIC the **IF** statement can have the form: **IF** *condition* **THEN** *line number* This means the same as: **IF** *condition* **THEN GO TO** *line number/label* ### ELSE By adding the optional **ELSE** clause, more complex decisions can be made. This instructs the computer to run another set of commands if the **IF...THEN** test turns out to be false. It is important to note that, unlike some other implementations of BASIC, **ELSE** must follow a colon within a statement line; for instance: ``` IF number<0 THEN PRINT "Negative number": ELSE PRINT "Positive number" ``` In the example above, if the condition is true (that is, the number is less than zero) then **Negative number** will be printed. If not, then **Positive number** will be printed on screen. But what if you for example wanted a third option to tell if the number is zero? You could use the ability to "nest" **IF...THEN** statements and use the **ELSE** clause to do so. Lets' rewrite the above: ``` IF number<0 THEN PRINT "Negative number": ELSE IF number>0 THEN PRINT "Positive number": ELSE PRINT "The number is zero ``` You should see in the above that it is possible to execute a further **IF...THEN** statement if the condition in the original one was false. *NextBASIC* will work through the **IF...THEN** statements until it finds a condition that is true, and will execute that. If no conditions are true, then it will attempt to execute the final **ELSE**. More than one command can be executed within each part of an **IF...THEN...ELSE** statement also, so: ``` IF number<0 THEN PRINT "Negative number": GO TO 100: ELSE IF number>0 THEN PRINT "Positive number": GO TO 200: ELSE PRINT "The number is zero" : zero += 1: GO TO 300 ``` will allow you to jump to different parts of the program dependent on the results of the **IF...THEN...ELSE** statements; in this case, whether the number is negative, positive or zero (note that if the number is zero, one is added to the variable **zero** as well). **IF...THEN...ELSE** however only works within a single program line and as a consequence it can be bulky and even somewhat unreadable. For that reason a longer form variation exists: **IF** *condition* [**ELSE** [**IF** *condition*]] *action* **END IF** It is immediately apparent that there is no **THEN** clause. This is what determines if it's the long, medium or short form of the **IF** structure. Medium and short forms use **THEN** and are thus single program line structures whereas the absence of **THEN** makes it the long form one. The long form **IF** has some specific syntax requirements. First off **IF** *condition* needs to be the first statement on its line and so are **ELSE** and **ELSE IF**. Secondly, the whole **IF** structure's command' sequence must be terminated by an **END IF** (which also needs to be the first statement on its line). Consider this example: ``` 100 IF x>7:PRINT "x>7" 112 IF x>1000 113 PRINT "In fact it's huge" 114 ELSE 115 PRINT "But not too big" 116 ENDIF 120 ELSE IF x>3:PRINT "x>3 but x<=7" 140 ELSE IF x=3 150 PRINT "x=3" 160 ELSE 170 PRINT "x is too small to bother" 180 ENDIF ``` It vividly demonstrates how a combination of nesting **IF...ELSE...ENDIF** structures within an external superset of **IF...ELSE...ENDIF** can allow multiple decisions in an easy straightforward way. The main decision is contained in the initial **IF** on line 100 and the ensuing **ELSE** clause on line 160. There we're checking if **x** is greater than **7** or not. Obviously **x** can be smaller than **7** but how small is immaterial? This gets asked by the **ELSE IF** clauses on lines 120 and 140 where it's decided that for values from **3** (line 140) *up to and including* **7** (line 120) – the value *of greater than* **7** has been dealt with on line 100 as we saw – it does indeed matter. There is however a set of values that **x** can have that is *greater than* **7** and that's what the nested **IF...ELSE...ENDIF** structure on lines 112 through 116 allows us to test against where we further break it down to values *greater than* **1000** or *less or equal to* **1000** (but still greater than **7**). The **PRINT** statements are there to demonstrate there's actions we can take per decision and could easily have been **GO TO** or **INPUT** or other sets of keywords actually doing something according to the value of **x**. Moreover, there are two styles of writing on display here. The compact one (lines 100 and 120) and the more relaxed with lots whitespace one (lines 140 to 180). ### Case selection with ON Many BASIC dialects contain a special structure called SELECT CASE which is a specialised version of **IF...ELSE IF...ENDIF** that's much easier to use and read. *NextBASIC* has a somewhat similar keyword called **ON**. Its syntax is as follows: **ON** *n*:\:\:\:...:\[: **ELSE** \] **ON** uses the resulting integer of rounding the value of expression *n* to the closest integer and executes the *n*^th statement of the same line that follows it. When the statement is executed, **ON** skips the rest of the line and moves to the next line, unless the statement was a non-returning jump such as **GO TO**, **EXIT**, **RETURN** or **ENDPROC**. If **ON** runs out of statements (in other words the integer part of **n** is greater than the number of statements that follows it, then, if the optional **ELSE** clause is present, all the statements that follow **ELSE** are executed otherwise the entire line is skipped. For example: ``` 100 ON x:GO TO @xwaszero:GO TO @xwasone:STOP: GOSUB 200: ELSE BEEP 1,0: PRINT "x was > 3":STOP 110 PRINT "execution returned":STOP 200 PRINT "I'm in the subroutine now" 210 RETURN ``` It's easy to understand that if **x** is **2** then the program will terminate, if it's **0** it will jump to label **@xwaszero**, if it's **1** it will jump to label **@xwasone**, if it was **3** it will jump to the subroutine on line 200, return and continue at line 110 and in every other case the computer will beep and inform us that **x** was greater than **3** before finally halting. While at first sight this may not display much improvement over the nested **IF...ELSE...END IF** structure especially since it can only check for values greater than **0**, in reality however you can prepare the variable to be checked ahead of time and simply test for that and moreover it is much simpler even typing-wise and more concise. ### Decisions with the ? operator A final way of making decisions but this time within the confines of a single statement that accepts a parameter is provider via the *select operator* **?** (question mark). This has the following form: _n_**?**(*expr0*,*expr1*,*expr2*...) If this reminds you a bit of the **ON** keyword syntax above you'd be correct as based on the value of **n** the *n*^th expression on the list is evaluated. If you run out of expressions in the list then the last expression is always evaluated. The select operator can take either numeric (be it floating point or integer) or string values in its evaluation list, however they all have to be the same. Although it's not immediately apparent how one could use it in te decision-making process, type and RUN the following example which will make it all clear: ``` 10 INPUT "Enter a number "; n 20 PRINT n?(%5, %10, %20) 30 PRINT n?("n is zero", "n is one", "n is two", "n is ``` ``` three", "n is four or more") 40 GO TO n?(100, 60, 120, 130, 10) 50 STOP 60 PRINT "n was one": STOP 100 PRINT "n was zero": STOP 120 PRINT "n was two": STOP 130 PRINT "n was three": STOP ``` (Do not mind the **%** symbols in the list of line 20; we will learn more about them in *Chapter 6 – Expressions*). As you enter values in the program, you will see how your input affects both the **PRINT** statements but also (and here's the important part) the **GO TO** statement on line 40 in effect creating a *conditional* **GO TO**. Moreover, instead of having to type 5 different **GO TO** statements like we would have in the case of **IF...ELSE...END IF** and **ON**, we only have to type one making it a great time-saver. Obviously the ability of the *select operator* to take either *string* or *numeric expressions* as parameters makes it useful for many things like for example a *conditional* **LET** apart from changing the flow of our program, so other than just line numbers we just used, we can make it calculate and further enhance our decision making as we'll see in *Chapter 6*.