Boolean statements are evaluations that return true (-1) or false (0) values. This are for instance the Relational Operations, but also functions such as _FILEEXISTS, EOF, _SCREENEXISTS etc. return those values when checking for certain conditions. The results of those evaluations or function calls can be used in other mathematical or logical operations.
Relational Operations
- True relational evaluations return -1, which can be used to increment or decrement a value by using the appropriate operations:
- either use addition to decrement and substraction to increment (due to the negative sign),
- or ABS the result first and then use substraction to decrement and addition to increment.
- False relational evaluations return 0. Watch out for Division by 0 errors here, if divisions are involved in the further processing.
Logical Operations
- Any of the logical operations can be used to further process or combine several conditions, but most useful are:
- AND to add extra conditions to a boolean statement evaluation.
- OR to add alternate conditions to a boolean statement evaluation.
- Parenthesis are allowed inside of boolean statements to clarify an evaluation.
Table 3: The relational operations for condition checking.
In this table, A and B are the Expressions to compare. Both must represent
the same general type, i.e. they must result into either numerical values
or STRING values. If a test succeeds, then true (-1) is returned, false (0)
if it fails, which both can be used in further Boolean evaluations.
┌─────────────────────────────────────────────────────────────────────────┐
│ Relational Operations │
├────────────┬───────────────────────────────────────────┬────────────────┤
│ Operation │ Description │ Example usage │
├────────────┼───────────────────────────────────────────┼────────────────┤
│ A = B │ Tests if A is equal to B. │ IF A = B THEN │
├────────────┼───────────────────────────────────────────┼────────────────┤
│ A <> B │ Tests if A is not equal to B. │ IF A <> B THEN │
├────────────┼───────────────────────────────────────────┼────────────────┤
│ A < B │ Tests if A is less than B. │ IF A < B THEN │
├────────────┼───────────────────────────────────────────┼────────────────┤
│ A > B │ Tests if A is greater than B. │ IF A > B THEN │
├────────────┼───────────────────────────────────────────┼────────────────┤
│ A <= B │ Tests if A is less than or equal to B. │ IF A <= B THEN │
├────────────┼───────────────────────────────────────────┼────────────────┤
│ A >= B │ Tests if A is greater than or equal to B. │ IF A >= B THEN │
└────────────┴───────────────────────────────────────────┴────────────────┘
The operations should be very obvious for numerical values. For strings
be aware that all checks are done case sensitive (i.e. "Foo" <> "foo").
The equal/not equal check is pretty much straight forward, but for the
less/greater checks the ASCII value of the first different character is
used for decision making:
E.g. "abc" is less than "abd", because in the first difference (the 3rd
character) the "c" has a lower ASCII value than the "d".
This behavior may give you some subtle results, if you are not aware of
the ASCII values and the written case:
E.g. "abc" is greater than "abD", because the small letters have higher
ASCII values than the capital letters, hence "c" > "D". You may use
LCASE$ or UCASE$ to make sure both strings have the same case.
|
Table 4: The logical operations and its results.
In this table, A and B are the Expressions to invert or combine.
Both may be results of former Boolean evaluations.
┌────────────────────────────────────────────────────────────────────────┐
│ Logical Operations │
├───────┬───────┬───────┬─────────┬────────┬─────────┬─────────┬─────────┤
│ A │ B │ NOT B │ A AND B │ A OR B │ A XOR B │ A EQV B │ A IMP B │
├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
│ true │ true │ false │ true │ true │ false │ true │ true │
├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
│ true │ false │ true │ false │ true │ true │ false │ false │
├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
│ false │ true │ false │ false │ true │ true │ false │ true │
├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
│ false │ false │ true │ false │ false │ false │ true │ true │
└───────┴───────┴───────┴─────────┴────────┴─────────┴─────────┴─────────┘
Note: In most BASIC languages incl. QB64 these are bitwise operations,
hence the logic is performed for each corresponding bit in both
operators, where true or false indicates whether a bit is set or
not set. The outcome of each bit is then placed into the respective
position to build the bit pattern of the final result value.
As all Relational Operations return negative one (-1, all bits set) for
true and zero (0, no bits set) for false, this allows us to use these
bitwise logical operations to invert or combine any relational checks,
as the outcome is the same for each bit and so always results into a
true (-1) or false (0) again for further evaluations.
|
Examples
- Example 1
- Using 2 different boolean evaluations to determine a leap year.
- Explanation
- Both boolean evaluations will return -1 if the year is a leap year. It is not simply every four years as many people think (see Wikipedia). That is checked by the first evaluation (Y MOD 4 = 0) of each. In new century years like 1900 (which was not a leapyear) there is only one leap year every 400 years. 100 is used with MOD to see if there is a remainder. When that is true, the boolean return of that part of the first evaluation will be 0. The second returns -1 (which is actually added). In both evaluations the result of (Y MOD 400 = 0) indicates a century leap year.
INPUT "Enter a year greater than 1583: ", annum$
Y = VAL(annum$)
leap1 = (Y MOD 4 = 0 AND Y MOD 100 <> 0) OR (Y MOD 400 = 0)
leap2 = (Y MOD 4 = 0) - (Y MOD 100 = 0) + (Y MOD 400 = 0)
PRINT "Year = "; annum$, "Leap1 = "; leap1, "Leap2 = "; leap2
|
Evaluation for year 2000
leap1 = (-1 AND 0) OR -1 = -1 'the AND evaluation is false(0), so the OR value is used
leap2 = (-1) - (-1) + (-1) = -1 + 1 + -1 = -1
Evaluation for year 1900
leap1 = (-1 AND 0) OR 0 = 0 OR 0 = 0
leap2 = (-1) - (-1) + (0) = -1 + 1 + 0 = 0
|
- Example 2
- Moving an ASCII character using the arrow keys and boolean statements to determine the new coordinate.
SCREEN 12
COLOR 7
LOCATE 11, 20: PRINT "Using Screen 12 here to be in 80 X 30 coordinates mode"
LOCATE 13, 6: PRINT "Simple Example of Alternative programming without IF-THEN-ELSE Statements"
LOCATE 15, 1: PRINT "Use the four Cursor keys to move the yellow cursor, text will not be disturbed"
LOCATE 17, 12: PRINT "When you END the program with the ESC key, cursor will disappear"
cordx% = 40
cordy% = 15
DO
oldcordx% = cordx%
oldcordy% = cordy%
p% = SCREEN(cordy%, cordx%) 'get ASCII character code at present position
COLOR 14: LOCATE cordy%, cordx%: PRINT CHR$(178); 'print cursor character to position
WHILE cordx% = oldcordx% AND cordy% = oldcordy% AND k$ <> CHR$(27)
k$ = INKEY$
cordx% = cordx% + (k$ = (CHR$(0) + "K") AND cordx% > 1) + ABS(k$ = (CHR$(0) + "M") AND cordx% < 80)
cordy% = cordy% + (k$ = (CHR$(0) + "H") AND cordy% > 1) + ABS(k$ = (CHR$(0) + "P") AND cordy% < 30)
WEND
COLOR 7: LOCATE oldcordy%, oldcordx%: PRINT CHR$(p%); 'replace overwritten screen characters
LOOP UNTIL k$ = CHR$(27)
|
Code by AlgoreIthm
See also
Navigation:
Main Page with Articles and Tutorials
Keyword Reference - Alphabetical
Keyword Reference - By usage