Binary addition program in python

What an excellent opportunity to explore some Boolean Logic.

Adding binary like this can be done with two "half adders" and an "or"

First of all the "Half Adder" which is a XOR to give you a summed output and an AND to give you a carry.

[EDIT as per comments: python does have an XOR implemented as ^ but not as a "word" like and not or. I am leaving the answer as is, due to the fact it is explaining the Boolean logic behind a binary add]

As python doesn't come with a XOR, we will have to code one. XOR itself is two AND's (with reversed inputs) and an OR, as demonstrated by this:

This would result is a simple function, like this:

def xor(bit_a, bit_b):
    A1 = bit_a and (not bit_b)
    A2 = (not bit_a) and bit_b
    return int(A1 or A2)

Others may want to write this as follows:

def xor(bit_a, bit_b):
    return int(bit_a != bit_b)

which is very valid, but I am using the Boolean example here.

Then we code the "Half Adder" which has 2 inputs (bit_a, bit_b) and gives two outputs the XOR for sum and the AND for carry:

def half_adder(bit_a, bit_b):
    return (xor(bit_a, bit_b), bit_a and bit_b)

so two "Half Adders" and an "OR" will make a "Full Adder" like this:

As you can see, it will have 3 inputs (bit_a, bit_b, carry) and two outputs (sum and carry). This will look like this in python:

def full_adder(bit_a, bit_b, carry=0):
    sum1, carry1 = half_adder(bit_a, bit_b)
    sum2, carry2 = half_adder(sum1, carry)
    return (sum2, carry1 or carry2)

If you like to look at the Full Adder as one logic diagram, it would look like this:

Then we need to call this full adder, starting at the Least Significant Bit (LSB), with 0 as carry, and work our way to the Most Significant Bit (MSB) where we carry the carry as input to the next step, as indicated here for 4 bits:

This will result is something like this:

def binary_string_adder(bits_a, bits_b):
    carry = 0
    result = ''
    for i in range(len(bits_a)-1 , -1, -1):
        summ, carry = full_adder(int(bits_a[i]), int(bits_b[i]), carry)
        result += str(summ)
    result += str(carry)
    return result[::-1]

As you see we need to reverse the result string, as we built it up "the wrong way".

Putting it all together as full working code:

# boolean binary string adder

def rjust_lenght(s1, s2, fill='0'):
    l1, l2 = len(s1), len(s2)
    if l1 > l2:
        s2 = s2.rjust(l1, fill)
    elif l2 > l1:
        s1 = s1.rjust(l2, fill)
    return (s1, s2)

def get_input():
    bits_a = input('input your first binary string  ')
    bits_b = input('input your second binary string ')
    return rjust_lenght(bits_a, bits_b)

def xor(bit_a, bit_b):
    A1 = bit_a and (not bit_b)
    A2 = (not bit_a) and bit_b
    return int(A1 or A2)

def half_adder(bit_a, bit_b):
    return (xor(bit_a, bit_b), bit_a and bit_b)

def full_adder(bit_a, bit_b, carry=0):
    sum1, carry1 = half_adder(bit_a, bit_b)
    sum2, carry2 = half_adder(sum1, carry)
    return (sum2, carry1 or carry2)

def binary_string_adder(bits_a, bits_b):
    carry = 0
    result = ''
    for i in range(len(bits_a)-1 , -1, -1):
        summ, carry = full_adder(int(bits_a[i]), int(bits_b[i]), carry)
        result += str(summ)
    result += str(carry)
    return result[::-1]

def main():
    bits_a, bits_b = get_input()
    print('1st string of bits is : {}, ({})'.format(bits_a, int(bits_a, 2)))
    print('2nd string of bits is : {}, ({})'.format(bits_b, int(bits_b, 2)))
    result = binary_string_adder(bits_a, bits_b)
    print('summarized is         : {}, ({})'.format(result, int(result, 2)))

if __name__ == '__main__':
    main()

two internet sources used for the pictures:

• https://www.electronics-tutorials.ws/combination/comb_7.html
• https://www.allaboutcircuits.com/textbook/digital/chpt-7/the-exclusive-or-function-xor/

For fun, you can do this in three lines, of which two is actually getting the input:

bits_a = input('input your first binary string  ')
bits_b = input('input your second binary string ')
print('{0:b}'.format(int(bits_a, 2) + int(bits_b, 2)))

And in your own code, you are throwing away a carry if on second/subsequent iteration one of the bits are 0, then you set x = 0 which contains the carry of the previous itteration.

this is how i managed to complete this, hope you find this useful.

#Binary multiplication program.
def binaryAddition(bin0, bin1):
    c = 0
    answer = ''

    if len(bin0) > len(bin1):
        bin1 = (len(bin0) - len(bin1))*"0" + bin1

    elif len(bin1) > len(bin0):
        bin0 = (len(bin1) - len(bin0))*"0" + bin0  

    #Goes through the binary strings and tells the computer what the anser should be.
    for i in range(len(bin0)-1,-1,-1):
        j = bin0[i]
        k = bin1[i]
        j, k = int(j), int(k)

        if k + j + c == 0:
            c = 0
            answer = '0' + answer
        elif k + j + c == 1:
            c = 0
            answer = '1' + answer
        elif k + j + c == 2:
            c = 1
            answer = '0' + answer
        elif k + j + c == 3:
            c = 1
            answer = '1' + answer
        else:
            print("There is something wrong. Make sure all the numbers are a '1' or a '0'. Try again.") #One of the numbers is not a 1 or a 0.
            main()

    return answer


def binaryMultiplication(bin0,bin1):
    answer = '0'*8
    if len(bin0) > len(bin1):
        bin1 = (len(bin0) - len(bin1))*"0" + bin1

    elif len(bin1) > len(bin0):
        bin0 = (len(bin1) - len(bin0))*"0" + bin0

    for i in range(len(bin0)-1,-1,-1):
        if bin1[i] == '0':
            num = '0'*len(answer)
        elif bin1[i] == '1':
            num = bin0 + '0'*((len(bin0)-1)-i)
        answer = binaryAddition(num, answer)
    print(answer)


def main():
    try:
        bin0, bin1 = input("Input both binary inputs separated by a space.\n").split(" ")
    except:
        print("Something went wrong. Perhaps there was not a space between you numbers.")
        main()

    binaryMultiplication(bin0,bin1)

    choice = input("Do you want to go again?y/n\n").upper()
    if choice == 'Y':
        main()
    else: input()

main()

The following adds integers i1 and i2 using bitwise logical operators (i1 and i2 are overwritten). It computes the bitwise sum by i1 xor i2 and the carry bit by (i1 & i2)<<1. It iterates until the shift register is empty. In general this will be a lot faster than bit-by-bit

while i2:                               # check shift register != 0
    i1, i2 = i1^i2, (i1&i2) << 1        # update registers