<<    Index    >>	FutureBasic
and - bitwise		operator

Syntax
result = exprA {and | &} exprB

Description
Expression exprA and expression exprB are each interpreted as 32-bit integer quantities. The and operator performs a bitwise comparison of each bit in exprA with its corresponding bit position in exprB. The result is another integer quantity; each bit in the result is determined as follows:

Bit value in exprA	Bit value in exprB	Bit value in result
0	0	0
1	0	0
0	1	0
1	1	1

Example
In the following example, expressions are evaluated as true or false before a decision is made for branching. The logical expression time>7 is true, and is therefore evaluated as 1. The expression time<8.5 is false, and is therefore evaluated as 0. Then the bitwise comparison (1) and (0) is performed, resulting in zero. Finally, the if statement interprets this zero result as meaning "false," and therefore skips the first print statement.

time = 9.5
if ( time > 7 and time < 8.5 )
   print "It is time for breakfast!"
xelse
   print "We have to wait 'til noon to eat!"
end if

The example below shows how bits are manipulated with and:

defstr long
print bin$(923)
print bin$(123)
print "--------------------------------"
print bin$(923 and 123)

program output:
00000000000000000000001110011011
00000000000000000000000001111011
--------------------------------
00000000000000000000000000011011

Note
In a statement like if expr1 and expr2 then..., it is possible for " expr1 and expr2 " to be false even though each individual expr is evaluated as true. Consider this example:

JoeIsHere = 16
FredIsHere = 2
if JoeIsHere then print "Joe's here" else print "Joe's gone"
if FredIsHere then print "Fred's here"¬
  else print "Fred's gone"
if JoeIsHere and FredIsHere
  print "They're both here"
xelse
  print "They're not both here!"
end if

program output:
Joe's here
Fred's here
They're not both here!

This strange result happens because the expression "16 and 2" evaluates to 0, which is then interpreted as "false" by the if statement. This wouldn't have happened if we had set JoeIsHere to 1 and FredIsHere to 1, because the expression "1 and 1" evaluates to 1.

FB 7.0.18's logical 'and' addition (with the && operator) provides the correct result for the comparison shown above by avoiding the bitwise comparison. A logical 'and' ( && ) always produces true when comparing two positive integers like those shown in JoeIsHere and FredIsHere. Non-intuitive workarounds setting variables to 1, like the above suggests, are unnecessary.

See also
&&; nand; nor; not; ! - logical 'not'; xor; or; Appendix D - Numeric Expressions