Logical and Relational Expressions

Logical and relational operands are used in questions that have a true/false answer. Expressions composed of logical and relational operands play a central role in ALADDIN programming constructs for the branching and looping control of problem solving procedure.

LOGICAL OPERANDS

ALADDIN supports three logical operands on physical quantities. They are:

```    OPERAND           DESCRIPTION
====================================================

||                Logical "or"
&&                Logical "and"
!                Logical "not"

====================================================
```

Expressions involving logical operands will evaluate to either true or false. In keeping with other programming languages, "true" is represented by a non-zero number, and "false" by zero.

Example 1 : In our first example,

```    print "2 && 3   : ", 2 && 3, " (true)  \n";
print "2 && 0   : ", 2 && 0, " (false) \n";
print "2 || 0   : ", 2 || 0, " (true)  \n";
print "0 || 0   : ", 0 || 0, " (false) \n";
print "!0       : ", !0    , " (true)  \n";
print "!2       : ", !2    , " (false) \n";
```
we simply evaluate logical operands for a variety of non-zero and zero number combinations. The generated output is:
```    2 && 3   :          1  (true)
2 && 0   :          0  (false)
2 || 0   :          1  (true)
0 || 0   :          0  (false)
!0       :          1  (true)
!2       :          0  (false)
```

Example 2 : Logical operand also work on physical quantities having units. For example, the script

```    print "2 cm && 3 cm : ", 2 cm && 3 cm, " (true)  \n";
print "0 cm/sec && 3 cm^2  : ", 0 cm && 3 cm, " (false)  \n";
```
generates the output
```    2 cm && 3 cm :           1  (true)
0 cm/sec && 3 cm^2  :    0  (false)
```
In each case, the logical operand in applied to the numerical component of the physical quantity alone (the units play no role in the operand's evaluation).

RELATIONAL OPERANDS

The relational operands are:

```    OPERAND           DESCRIPTION
====================================================

==                Test for "identical equality"
>                Greater than
<                Less than
>=                Greater than or equal to
<=                Less than or equal to

====================================================
```

Example 3 : Expressions involving relational opeators may be applied directly to physical quantities -- for example, the script:

```    print "2 cm == 3 cm : ", 2 cm == 3 cm, " (false)  \n";
print "2 cm >  3 cm : ", 2 cm >  3 cm, " (false)  \n";
print "2 cm <  3 cm : ", 2 cm <  3 cm, " (true)   \n";
print "2 cm <= 3 cm : ", 2 cm <= 3 cm, " (true)   \n";
```
generates the output
```    2 cm == 3 cm :          0  (false)
2 cm >  3 cm :          0  (false)
2 cm <  3 cm :          1  (true)
2 cm <= 3 cm :          1  (true)
```

Example 4 : A key feature of ALADDIN's units package is checking of compatible units before a logical or relational operand is evaluated. In the following script, we show how sets of mixed units may be used in relational expressions -- the script of code:

```    print "20 cm  == 200 mm : ", 20 cm == 200 mm, " (true)  \n";
print "12 in   >   1 ft : ", 12 in  >   1 ft, " (false)  \n";
print "36 in  => 100 cm : ", 36 in  > 100 cm, " (false)  \n";
```
generates the output
```    20 cm  == 200 mm :          1  (true)
12 in   >   1 ft :          0  (false)
36 in  => 100 cm :          0  (false)
```
Everything works as expected. Now suppose that we make a small error, as in the script:
```    x = 20 cm;
y = 20 cm/sec;

print "20 cm => 20 cm/sec : ", x > y , " (huh ???)  \n";
```
```    20 cm => 20 cm/sec :
FATAL ERROR >> "In Quantity_Gt() : Inconsistent Dimensions"
```
and terminates its execution.

LOGICAL AND RELATIONAL EXPRESSIONS

Of course logical and relational operands may be combined. Here are a couple of examples:

Example 5 : The script

```    x = 20 cm > 10 cm;
y = 20 sec >= 100 sec ;

print "x : ", x , " (true)  \n";
print "y : ", y , " (false)  \n";
print "x || y : ", x || y , " (true)  \n";
print "x && y : ", x && y , " (false)  \n";
```
generates the output
```    x :          1  (true)
y :          0  (false)
x || y :          1  (true)
x && y :          0  (false)
```
Note : Further examples may be found in the sections on branching constructs and looping constructs.

Developed in April 1996 by Mark Austin