# Relational Operations

QB64 supports several relational operations, which are binary operations that test numeric or string values and return an INTEGER value representing a boolean *true* (`-1`) or *false* (`0`) result. These operations are primarily used in expressions where a condition is required, such as the IF...THEN statement.

## List of relational operations

The following table describes the relational operations, where `A` is the left-hand side operand, and `B` is the right-hand side operand:

**Relational Operations**Operation Description a = b Tests if a is equal to b. a <> b Tests if a is not equal to b; equivalent to (NOT (a = b)). a < b Tests if a is less than b. a > b Tests if a is greater than b. a <= b Tests if a is less than or equal to b; equivalent to (NOT (a > b)). a >= b Tests if a is greater than or equal to b; equivalent to (NOT (a < b)).

## Comparing numerical values and variables

For numeric operands, such as INTEGER or DOUBLE values, the relational operations behave as one would expect. For example, the expression (-3.4 < 1.2) evaluates to *true*, and the expression (50 = 100) evaluates to *false*.

*Example:* When a user enters a value greater than or equal to 5, the boolean statement returns -1 . Zero is printed otherwise.

* *
INPUT "Enter a value from 1 to 10: ", number
PRINT number >= 5 * *

## Comparing string values and variables

For string operands, the = and <> operators test, respectively, if the operands are of the same or differing length, and that each of the corresponding characters match or don't match. For example, the three expressions ("abc" = "abc"), ("abc" <> "abd") and ("abc" <> "abcdef") all evaluate to *true*.

When two strings are compared, the left string sets the number of characters to evaluate when not checking for equality. The < and > operators find the first set of non-matching characters and test if the ASCII code values of those characters are less than or greater than each other, respectively. **Equal strings MUST be of the same length with identical cased letters or ASCII characters!**

If one string is identical to part of the other, < returns *false* if the left-hand side string is shorter than the right-hand side string, while > returns *true* if the left-hand side string is longer than the right-hand side string. For example, the expressions ("abc" < "abd") and ("abcdef" > "abc") both evaluate to *true*. Even space ASCII character values are evaluated!

*Example:* Shows that the left hand string sets the number of characters to evaluate when using > or < and are not equal when longer.

* *
PRINT "abc" < "abcd"
PRINT "abc" = "abc"
PRINT "abc" = "abcd"
PRINT "abcd" > "abc" * *

0 -1 0 -1

## Comparing user-defined type variables

Variables of a user-defined type (UDT) cannot be used as operands to the relational operators, but numeric or string type fields can be used as described above. For example:

- TYPE T
- a AS INTEGER

- END TYPE

- TYPE T

- TYPE U
- b AS INTEGER

- END TYPE

- TYPE U

- DIM x AS T : x.a = 10
- DIM y AS U : y.b = 20

- PRINT x < y ' <- error: type mismatch
- PRINT x.a < y.b ' <- outputs "-1"

## Boolean values

The INTEGER values for *true* and *false* are such that the bitwise Logical Operators, such as NOT, AND and OR can be used to invert and combine test results. For example, the expression (NOT (10 >= 20)) evaluates to *true*, while the expression ((2 < 1) AND ("three" = "four")) evaluates to *false*.

*A*and

*B*are operands, and

*T*and

*F*indicate that a bit is set or not set:

Operands Operations A B `NOT B``A AND B``A OR B``A XOR B``A EQV B``A IMP B`T T F T T F T T T F T F T T F F F T F F T T F T F F T F F F T T

**Relational Operations**return negative one (-1, all bits set) and zero (0, no bits set) for*true*and*false*, respectively.

## See also

*Navigation:*