General:Boolean (also called
Logical) operators are used for marking elements. They are also used for
testing marked elements. A marked element is true or 1; an unmarked element is
false or 0. Most of these operations are very familiar. For these examples, I
have used Glee's shorthand for boolean values. This is a
character string containing just characters '1' and '0'. For
example, the 4 character string (vector) "0101" is
interpreted by the boolean operators as a bit vector with values
(false,true,false,true). In writing Glee programs you will likely
find no use for this style of boolean input. Your boolean values will originate
by making tests. I included this facility in Glee so I could
easily present examples and as a sculpting aid.
Logical operators:The
logical operators AND (&), OR (|),
NOT (~), NAND (~&), NOR
(~), and XOR (^) assume boolean left arguments. All
are dyadic except for NOT which is monadic. These examples give the
truth tables for these operations. As in other cases, Glee does
right takes on numeric arguments for length conformity and left
takes for other objects. In Glee, boolean values are stored
in characters, eight per character. This version of Glee does not
take advantage of the computer's ability to operate on these bits directly.
Glee actually indexes each bit to perform these operations. When
I get Glee up, stable, and doing real work, I'll go back and
optimize these boolean operators. There is a 100 times speed improvement
potential there.
Mark All (*&):Mark where
all the elements in the right argument are found in the left argument (in the
order presented)
Mark Any (*|):Mark where any
of the elements in the right argument are found in the left argument
Contains All (^&):True
if left argument contains all of the right argument (in the order presented)
Contains Any (^|):True if
left argument contains any of the right argument
Mark Contains All
(*^&):Mark where elements in the left argument contain all the
elements in the right argument (in the order presented) testing element by
element. This operator is only meaningful for complex arguments like sequences
where you want to do an element by element test (e.g. each string in a
sequence). The same thing can be accomplished with ALeft @& ^&
ARight < . However, this is less efficient since it first creates a
sequence of bit singletons and then exposes it into a bit vector. The
*^& operator returns the bit vector directly so runs faster and
uses less space.
Mark Contains Any (*^|):Mark
where elements in the left argument contain any of the elements in the right
argument, testing element by element.This operator is only meaningful for
complex arguments like sequences where you want to do an element by element
test (e.g. each string in a sequence). The same thing can be accomplished with
ALeft @& ^| ARight < . However, this is less efficient since it
first creates a sequence of bit singletons and then exposes it into a bit
vector. The *^| operator returns the bit vector directly so runs
faster and uses less space.
Marking:The relational
operators: Less Than (<); Less Than or Equal To (<=);
Equal to(=); Not Equal to(~=); Greater Than or Equal To
(>=); and Greater Than (>) perform comparisons of their
arguments element by element and return the results of these tests as boolean
vectors. As is characteristic of Glee, length conformity is
forced with right take for numerics and left take for other
objects. Caution: don't use (=>) as Equal To or Greater
Than. This is Glee's assignment operator.
Not example:You might have
noticed I deviated in the example style in the case of NOT. I would
have liked to use the example ("01"~) remaining consistent
with the other examples. However, the tilde symbol (~)denotes the
without operation in non-boolean cases. In regard to character vectors,
it removes redundant white space. So in this case, it would have just returned
itself, "01". So I have performed a relational test (10
20=10) which gives me a boolean vector result ("10"). I
then apply the NOT (~) operator to this result yielding
("01").
Greater Than or Equal
To:Caution:You may be tempted to use the symbol
(=>) for Equal To or Greater Than. Don't. That is the symbol
for assignment in Glee.
Manifest constants: As I
describe in the Glossary,
Glee does not have manifest constants. However, it does have
niladic functions #TRUE and #false (as with all
Glee, case is not significant). These can be assigned to
variables with names of your choice which then behave as manifest constants.
To Index and Indexing with:
After you have completed boolean tests you usually want to do something with
the result. Glee allows you to use the result directly as an
index into a Glee vector. Or you can convert the bit vector to a
vector of indices where bits are set. You can then use this for indexing.
Boolean indexing is more efficient than numeric indexing.