Arithmetic Operators

Arithmetic operators do exactly what they say, they perform simple arithmetic operations such as addition and subtraction. All arithmetic operators are binary operators, thus they all accept two input values (an lvalue and an rvalue) and output one value, the evaluation of the lvalue and rvalue.

+ (addition)
- (subtraction)
* (multiplication)
/ (division)
% (modulus) [returns the remainder of a division]

Logical Operators

Logical operators are a little more complex to explain, but they are actually just primitive operators that can be used in combination to produce more complex operators. Logical operators can be split into two categories: unary operators and binary operators. A unary operator has just one input, while a binary operator has two inputs. Logical operators are also known as bitwise operators because each operates upon corresponding bits of the operands. Since they operate at the bit-level, they are also known as boolean operators. An individual bit can only be 0 or 1 (false or true) thus we can build simple truth tables to determine what the output bit will be for any given input bit.

Logical NOT

The logical NOT operator is the simplest operator to understand because it is a unary operator and therefore has only one input. It's sole purpose is to invert the input value on a bit-by-bit basis to produce an output. Since an input bit can only ever be 1 or 0, the NOT truth table is relatively simple:

input 0 1

output 1 0

Each bit of an input is handled separately according to this table. Thus NOT(00000000) will output 11111111, while NOT(11111111) will output 00000000. Likewise, NOT(10101100) would output 01010011.

Inside your computer you will actually have at least 32 logical NOT circuits that operate simultaneously, thus allowing multi-bit values to be handled as a single operation. That is, each individual circuit operates upon one bit of the input.

Logical Binary Operators

Since binary operators have two inputs, the truth tables are a little more complex than that of the NOT operator. The two inputs are typically represented by the values p and q. The simplest operator is the AND operator, which has the following truth table:

p q output

0 0 0

0 1 0

1 0 0

1 1 1

You will note that the output is true only when both inputs are true. You will also note that there are four possible outputs for any two inputs. Thus with four possible outputs, there has to be 16 possible combinations of output. And in order to represent all possible outputs we therefore need 16 logical bitwise operators, of which the AND operator is just one.

Thus the complete truth table for all logical binary operators is as follows:

p q 0 1 2 3 4 5 6 7 8 9 A B C D E F

0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

0 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1

1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

The outputs are represented by the hexadecimal values 0 through F. If you read down a column you will note that the combined bit values correspond to the column header. Thus the AND operator, with outputs 0001, is represented by column 1.

Columns 6 and 7 are the most interesting of the remaining columns as column 7 represents the logical OR operator while column 6 is the logical XOR operator (exclusive OR). Along with AND, these are the only three logical operators that are actually required. You might ask why we don't have operators for the remaining 13, but we do -- it's just that we don't have any specific operators for them. We simply combine the AND, OR and XOR operators with the unary NOT operator in order to achieve them.

In actual fact, the last 8 operators are simply the inverse of the first 8 (column F is the inverse of column 0, column E is the inverse of column 1, and so on). Thus NOT( p AND q ) produces the results shown in column E. This particular operator is commonly called the NAND operator. By the same token, column 8 is the NOR operator and column 9 is the XNOR operator. Most languages do not provide these specific operators but we can reproduce them using NOT with AND, OR and XOR respectively.

Columns 0 and F (the contradiction and tautology operators, respectively) are essentially redundant since they have no practical usage. However, they are logical binary operators, nevertheless.

We can summarise all the logical binary operators as follows:

0 : contradiction

1 : p AND q

2 : p AND NOT(q)

3 : p

4 : q AND NOT(p)

5 : q

6 : p XOR q

7 : p OR q

8 : p NOR q (e.g., NOT(p OR q))

9 : p XNOR q (e.g., NOT(p XOR q))

A : NOT(q)

B : NOT(q AND NOT(p))

C : NOT(p)

D : NOT(p AND NOT(q))

E : p NAND q (e.g., NOT(p AND q))

F : tautology

You will note that A and C are already catered for with the unary NOT operator alone. You will also note that 3 and 5 are the inverse of A and C, and are both known as unary projection functions. Along with 0 and F, these 6 operators are completely redundant, leaving us with 10 useful logical binary operators, all of which can be created by combining NOT with the 3 most basic operators: AND, OR and XOR.

Resources

Top Categories

Product

Company