 Operators
PowerBASIC supports a pretty much standard set of operators. Some languages have operators specific to string or number types, but PowerBASIC operators work on both types. Here's a compact listing of the operators PowerBASIC supports. This tutorial breaks these into common groups for discussion.

Note that operators can be made of letters (such as MOD) and do not always consist of special characters.

```     +       +=       <       AND     AND=
-       -=       >       OR      OR=
*       *=       <>      NOT     NOT=
/       /=       ><      XOR     XOR=
\       \=       <=      EQV     EQV=
MOD     MOD=     =<      IMP     IMP=
^                >=
ISTRUE           =>
ISFALSE
```

Basic Arithmetic
The following, industry-standard operators are used to perform basic arithmetic operations.

```    =     x = 2       # assignment
+     x = x + 1   # add
-     x = x - 1   # subtract
*     x = x * 2   # multiply
/     x = x / 2   # divide
\     x = x \ 2   # integer division
^     x = x^2     # raises x to the power of 2
MOD   x MOD 5     # modulus (whole number remainder of division)
```

MOD is an example of an operator that is defined using letters rather than special characters.

Relational Operators
These operators compare two values or expressions. They return a Boolean result of TRUE (-1) or FALSE (0). Since they return a numeric result, they can be use in numerical expressions to return a -1 or 0. However, relational operators are most notably used in flow control structures, such as IF, DO, WHILE, etc., which use the TRUE/FALSE value of an expression to determine which source code statements to execute.

```    <                 # less than
>                 # greater than
<>  or  ><        # not equal to
<=  or  =<        # less than or equal to
>=  or  =>        # great than or equal to
```

When used with strings, the ASCII values of each character in the string form the basis for the comparison. For example, "a" is less than "A" because their respective ASCII codes are 39 and 65.

String Concatenation
The PowerBASIC uses two operators (+ and &) to join strings.

```     b\$ = "dog"      'assign "dog" to string variable a\$
c\$ = "cat"      'assign "cat" to string variable c\$
a\$ = b\$ + c\$    'a\$ = "catdog"
a\$ = b\$ & c\$    'a\$ = "catdog"
```

This is a comparative slow process and programmers are advised to use the special BUILD\$ function which concatenates strings with much greater speed, particularly with larger numbers of strings to concatenate.

Boolean Values and PowerBASIC Functions
Before getting into PowerBASIC Boolean operators, here are some points to remember when dealing with Boolean values and PowerBASIC functions.

• In PowerBASIC, numeric zero or an empty string are treated as FALSE. All other values are considered TRUE.

• PowerBASIC functions which return a Boolean result return -1 to indicate TRUE and 0 to indicate FALSE.

• Some PowerBASIC operators evaluate expressions in terms of their TRUE/FALSE value and some act on the numeric/string value of the expression.

Boolean Operators
These PowerBASIC operators can be used in two ways - to compare the TRUE/FALSE value of two expressions, or to manipulate the content of a variable at the bit level. All but the NOT operator work on two expressions.

```    and    # TRUE if both expressions TRUE
or     # TRUE if either expression TRUE
xor    # TRUE if arguments have different Boolean values
not    # returns bitwise one's-complement of a single argument
eqv    # TRUE if arguments have same Boolean values
imp    # FALSE only if 1st argument is T and 2nd argument is F
```

From a Boolean viewpoint, when dealing with values 0 and -1, NOT works as expected. But when NOT is used on other values, it can provide unexpected results. This is because NOT works at the bit level, not on a Boolean level. In cases where the expression to be evaluated is other than 0 or -1, the ISFALSE and ISTRUE operators should be used to deal with values on a Boolean level.

Bit Manipulations by Boolean Operators
All of the Boolean operators above operate at the bit level. The section above shows how the operators can successfully be used to perform Boolean tests. Here is a description of the bit-level effect of the operators. You can see how the AND/OR and NOT/XOR pairs provide effects opposite to one another.

```    AND   sets selected bits to 0 without affecting the other bits
OR    sets selected bits to 1 without affecting the other bits

NOT   reverses all bits
XOR   reverses selected bits
```

The EQV and IMP also perform bit-level manipulation but the results are seldom used for that purpose. The Boolean descriptions of the prior section describe the effects most useful to programmers.

Compound Operators
To simplify coding, PowerBASIC also offer the ability to combine the following operator pairs for common operations. The operator, its use, and the equivalent expressions are given in the following table.

```     +=     x+=5        x = x+5
-=     x-=5        x = x-5
*=     x*=5        x = x*5
/=     x/=5        x = x/5
\=     x/=5        x = x\5
MOD=   x%=5        x = x%5

AND=   x AND= 6    x = x AND 6
OR=    x OR= 5     x = x OR 5
XOR=   x XOR= 3    x = x XOR 3
EVQ=   x EQV= 6    x = x EQV 6
IMP=   x IMP= 2    x = x IMP 2

+=     x += "dog"  x = x + "dog"
&=     x &= "dog"  x = x & "dog"
```

All of these compound operators are described as replacing a variable with its value modified (according to the operator type) by a second value.

Quote Operators
Other languages, such as Perl, provide the ability to insert variables into quotes and at execution, substitute the variable value for the variable name. The method is a shortcut for concatenating strings and variable values.

This is called interpolation and is not supported by PowerBASIC.

If you have any suggestions or corrections, please let me know.