# Boolean Operations

Tom Kelliher, CS 116

Oct. 23, 2000

### From Last Time

Arithmetic operations: precedence, associativity.

### Outline

1. Logical operators.

2. Precedence, associativity exercise.

3. Assignment operators.

4. Primitive variables vs. class variables.

### Coming Up

`if` statement, Lab 5.

# Logical Operators

Comparison and boolean operators.

## Arithmetic Comparison Operators

`<`, `<=`, `==`, `!=`, `>`, `>=`.

1. Lower precedence than binary arithmetic operators.

Equality, inequality one level below others.

2. Associate left-to-right.

3. Take numeric arguments. Return a `boolean`.

Why is `0.0 < x < 1.0` illegal?

Examples. Assume:

```int    n = 3;
double x = 4.8;
```
Evaluate (explain):
```n < 3

n <= 3

n < x

(n + 3) == 2

2 * n != x - 1.0

n >= n

n / 4 > 0

n >= n == n < 3
```

## Logical Operators

1. Take `boolean` argument(s). Return a `boolean` value.

2. Binary: `&&`, `||`.

Lower precedence than equality, inequality.

Associate?

3. Unary: `!`.

Unary precedence.

Associate?

4. Deriving the truth tables.

# Precedence Table

1. Unary +, -, ++, --, !, (type) (right)
2. *, /, % (left)
3. Binary +, - (left)
4. <, <=, >, >= (left)
5. ==, != (left)
6. && (left)
7. || (left)
8. Assignment =, +=, -=, *=, /=, %=, etc. (right)

# ASCII Table

```  0 nul    1 soh    2 stx    3 etx    4 eot    5 enq    6 ack    7 bel
8 bs     9 ht    10 nl    11 vt    12 np    13 cr    14 so    15 si
16 dle   17 dc1   18 dc2   19 dc3   20 dc4   21 nak   22 syn   23 etb
24 can   25 em    26 sub   27 esc   28 fs    29 gs    30 rs    31 us
32 sp    33  !    34  "    35  #    36  \$    37  %    38  &    39  '
40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /
48  0    49  1    50  2    51  3    52  4    53  5    54  6    55  7
56  8    57  9    58  :    59  ;    60  <    61  =    62  >    63  ?
64  @    65  A    66  B    67  C    68  D    69  E    70  F    71  G
72  H    73  I    74  J    75  K    76  L    77  M    78  N    79  O
80  P    81  Q    82  R    83  S    84  T    85  U    86  V    87  W
88  X    89  Y    90  Z    91  [    92  \    93  ]    94  ^    95  _
96  `    97  a    98  b    99  c   100  d   101  e   102  f   103  g
104  h   105  i   106  j   107  k   108  l   109  m   110  n   111  o
112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w
120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del
```

# Assignment Operators

1. A common problem:
```if (a = 3)
// ...
```

2. Simple assignment. `=`: binary operator, right associative.

3. Assignment with operation. `+=`, `-=`, `*=`, etc.

Ok, name three ways of increasing `i` by one.

# Primitive Variables vs. Class Variables

Primitive variables hold values. Class variables hold references (memory addresses). You don't get what you expect when you assign class variables.

Examples. Diagram (memory allocation) the following:

1. Primitive variables
```int a = 3;
int b = 5;

b = a;
b++;
```
What are `a`'s and `b`'s values?

2. Class variables
```Point a = new Point(3, 3);
Point b = new Point(5, 5);

b = a;
b.x++;
b.y++;
```
What are `a`'s and `b`'s values?

Thomas P. Kelliher
Sun Oct 22 16:23:42 EDT 2000
Tom Kelliher