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 0s into 1s, 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.