# 2d: Bit Logic

`++con`

Binary OR

Computes the bitwise logical OR of two atoms, `a`

and `b`

, producing an atom.

#### Accepts

`a`

is an atom

`b`

is an atom

#### Produces

An atom.

#### Source

```
++ con
~/ %con
|= [a=@ b=@]
=+ [c=0 d=0]
|- ^- @
?: ?&(=(0 a) =(0 b)) d
%= $
a (rsh 0 1 a)
b (rsh 0 1 b)
c +(c)
d %+ add d
%^ lsh 0 c
?& =(0 (end 0 1 a))
=(0 (end 0 1 b))
==
==
```

#### Examples

```
> (con 0b0 0b1)
1
> (con 0 1)
1
> (con 0 0)
0
> `@ub`(con 0b1111.0000 0b1.0011)
0b1111.0011
> (con 4 4)
4
> (con 10.000 234)
10.234
> `@ub`534
0b10.0001.0110
> `@ub`987
0b11.1101.1011
> `@ub`(con 534 987)
0b11.1101.1111
> (con 534 987)
991
```

#### Discussion

`con`

performs the bitwise operation OR, a concept that's general to computing.
It compares each bit of its first sample to the corresponding bit of its second
sample. If either bit is 1, the corresponding product bit is set
to 1. Otherwise, the corresponding product bit is set to 0.

Take the example of `(con 8 12)`

. It's easy to see how this operation works when
its samples and its product are stacked.

```
0b1000 :: 8 (sample)
0b1100 :: 12 (sample)
0b1100 :: 12 (product)
```

Note that the names `con`

(conjunction) for OR and `dis`

(disjunction) for AND
are given to opposite operators in Hoon when compared to other computing
contexts. That's because `0`

is true in Hoon and `1`

is false. Outside of Hoon,
where `0`

is false and `1`

is true, bitwise OR is the logical disjunction and
bitwise AND is the logical conjunction.

`++dis`

Binary AND

Computes the bitwise logical AND of two atoms, `a`

and `b`

, producing an atom.

#### Accepts

`a`

is an atom.

`b`

is an atom.

#### Produces

An atom.

#### Source

```
++ dis
~/ %dis
|= [a=@ b=@]
=| [c=@ d=@]
|- ^- @
?: ?|(=(0 a) =(0 b)) d
%= $
a (rsh 0 1 a)
b (rsh 0 1 b)
c +(c)
d %+ add d
%^ lsh 0 c
?| =(0 (end 0 1 a))
=(0 (end 0 1 b))
==
==
```

#### Examples

```
> `@ub`9
0b1001
> `@ub`5
0b101
> `@ub`(dis 9 5)
0b1
> (dis 9 5)
1
> `@ub`534
0b10.0001.0110
> `@ub`987
0b11.1101.1011
> `@ub`(dis 534 987)
0b10.0001.0010
> (dis 534 987)
530
```

#### Discussion

`dis`

performs the bitwise AND, an operation general to computing. It compares
each bit of its first sample to the corresponding bit of its second sample. If
both bits are 1, the corresponding product bit is set to 1. Otherwise, the
corresponding product bit is set to 0.

Take the example of `(dis 8 12)`

. It's easy to see how this operation works when
its samples and its product are stacked.

```
0b1000 :: 8 (sample)
0b1100 :: 12 (sample)
0b1000 :: 8 (product)
```

Note that the names `dis`

(disjunction) for AND and `con`

(conjuction) for OR
are given to opposite operators in Hoon when compared to other computing
contexts. That's because `0`

is true in Hoon and `1`

is false. Outside of Hoon,
where `0`

is false and `1`

is true, bitwise OR is the logical disjunction and
bitwise AND is the logical conjunction.

`++mix`

Binary XOR

Produces the bitwise logical XOR of two atoms, `a`

and `b`

, producing an atom.

#### Accepts

`a`

is an atom

`b`

is an atom

#### Produces

An atom.

#### Source

```
++ mix
~/ %mix
|= [a=@ b=@]
^- @
=+ [c=0 d=0]
|-
?: ?&(=(0 a) =(0 b)) d
%= $
a (rsh 0 1 a)
b (rsh 0 1 b)
c +(c)
d (add d (lsh 0 c =((end 0 1 a) (end 0 1 b))))
==
```

#### Examples

```
> `@ub`2
0b10
> `@ub`3
0b11
> `@ub`(mix 2 3)
0b1
> (mix 2 3)
1
> `@ub`(mix 2 2)
0b0
> (mix 2 2)
0
> `@ub`534
0b10.0001.0110
> `@ub`987
0b11.1101.1011
> `@ub`(mix 534 987)
0b1.1100.1101
> (mix 534 987)
461
```

#### Discussion

`mix`

performs the bitwise XOR (exclusive-OR), an operation that's general to
computing. compares each bit of its first sample to the corresponding bit of its
second sample. If one bit is 0 and the other bit is 1, the corresponding product
bit is set to 1. Otherwise, the corresponding product bit is set to 0.

Take the example of `(mix 8 12)`

. It's easy to see how this operation works when
its samples and its product are stacked.

```
0b1000 :: 8 (sample)
0b1100 :: 12 (sample)
0b100 :: 4 (product)
```

`++not`

Binary NOT

Computes the bitwise logical NOT of the bottom `b`

blocks of size `a`

of `c`

.

#### Accepts

`a`

is a block size (see `bloq`

).

`b`

is an atom.

`c`

is an atom.

#### Produces

An atom.

#### Source

```
++ not |= [a=bloq b=@ c=@]
(mix c (dec (bex (mul b (bex a)))))
```

#### Examples

```
> `@ub`24
0b1.1000
> (not 0 5 24)
7
> `@ub`7
0b111
> (not 2 5 24)
1.048.551
> (not 2 5 1.048.551)
24
> (not 1 1 (not 1 1 10))
10
```

#### Discussion

In computing in general, the bitwise operation NOT simply turns a binary
number's `0`

s into `1`

s, and vice versa.

In Hoon, we ask for a little more information to use `not`

, because binary
numbers have a number of implicit leading zeroes differently depending on on
their block size. Decimal `7`

, for example, is `0b111`

in binary, and
has one implicit zero in the context of a block of size `2`

, which has a
bitwidth of 4. Let's try `not`

on `7`

with a single block of size `2`

.

```
> `@ub`(not 2 1 0b111)
0b1000
> `@u`0b1000
8
```

This happened because `0b111`

is considered as `0b0111`

by the `not`

operator
when dealing with a single block of size `2`

. The NOT of `7`

, then, is `0b1000`

,
or `8`

in decimal.

When we pass `not`

a single block of size `3`

, there is a bitwidth of 8 to
fill with binary information. So the remaining leading digits of `0b111`

are,
again, treated as `0`

.

```
> `@ub`(not 3 1 0b111)
0b1111.1000
> `@u`0b1111.1000
248
```

This works when going to a smaller block size, too.

```
> `@ub`(not 1 1 0b1011)
0b100
> `@u`0b100
4
```

What's happening here may not be readily apparent. But we're only flipping the
last block of size `1`

(bitwidth 2) of the binary `0b111`

. That is, we leave
the "0b1" piece just the same and manipulate the "11" that the number ends with.