Add two binairy numbers

add_bin.py

def bin_to_int(bin_val):
    """
      We draaien het binaire getal (string) om, zodat we van het
      grootste naar kleinste exponent kunnen werken. We kunnen daardoor
      van de eerste index naar de laatste index itereren en bij elke "1"
      de waarde optellen bij het subtotaal.
    """
    
    bin_val = bin_val[::-1]
    
    int_val = 0
    i = 0
    while i < len(bin_val):
        if bin_val[i] == "1":
            int_val = int_val + 2**i
        i = i + 1
        
    return int_val
    
def int_to_bin(int_val):
    """
      Deze functie is alleen bedoeld voor het aanmaken van de lege lijst
      met nullen. Deze lijst wordt samen met de gegeven numerieke waarde
      meegegeven aan de recursieve functie. De recursieve functie geeft
      de lijst van binaire waarden terug welke aan elkaar worden 'geplakt' tot een string mbv de 'join' functie.
    """
    bin_val=["0", "0", "0", "0", "0", "0", "0", "0"]
    
    bin_val = int_to_bin_rec(int_val,bin_val)
    
    return "".join(bin_val)
    
def int_to_bin_rec(int_val,bin_val):
    """
      Gegeven de numerieke waarde zoeken we eerst naar het grootste
      exponent. We onthouden tijdens het itereren de positie in het 
      binaire getal die hoort bij het grootste exponent. Die positie
      vervangen we door een "1", waarna we de numerieke waarde reduceren
      met de waarde behorende bij het grootste exponent. Dit doen we
      net zo lang totdat de numerieke waarde 0 is. Wanneer dit gebeurt
      hebben we de binaire waarde gevonden. Omdat we van groot naar 
      klein werken, moeten we de lijst nog wel omdraaien middels
      de reversed functie.
    """
    if int_val == 0:
        return reversed(bin_val)
        
    ## Dit...
    
    highest_exp = -1
    while int_val >= 2**(highest_exp+1):
      highest_exp = highest_exp + 1
    
    bin_val[highest_exp] = "1"
    int_val = int_val - 2**highest_exp
    
    ## ... is hetzelfde al dit, maar het scheelt
    ## dat je hier niet alle exponenten apart hoeft
    ## uit te schrijven. Bovenstaande code vindt
    ## namelijk automatisch het hoogste exponent.
    
    #if int_val >= 2**3:
    #    int_val = int_val - 2**3
    #    bin_val[3] = "1"
    #if int_val >= 2**2:
    #    int_val = int_val - 2**2
    #    bin_val[2] = "1"
    #if int_val >= 2**1:
    #    int_val = int_val - 2**1
    #    bin_val[1] = "1"
    #if int_val == 1:
    #    int_val = int_val - 2**0
    #    bin_val[0] = "1"
        
    return int_to_bin_rec(int_val,bin_val)	

## Tests om aan te tonen dat add_bin werkt
tests = [
  ["0000", 0],
  ["0001", 1],
  ["0010", 2],
  ["0011", 3],
  ["0100", 4],
  ["0101", 5],
  ["0110", 6],
  ["0111", 7],
  ["1000", 8],
  ["10000000", 128],
  ["11111111", 255],
]

for test in tests:
  result = bin_to_int(test[0])
  if result != test[1]:
    print('Fail. Expected ' + str(test[1]) + ', got ' + str(result) + '.')
  else:
    print('Success')
    
## Tests om aan te tonen dat int_to_bin werkt

tests = [
  [0, "00000000"],
  [1, "00000001"],
  [2, "00000010"],
  [3, "00000011"],
  [4, "00000100"],
  [5, "00000101"],
  [6, "00000110"],
  [7, "00000111"],
  [8, "00001000"],
  [128, "10000000"],
  [255, "11111111"],
]

for test in tests:
  result = int_to_bin(test[0])
  if result != test[1]:
    print('Fail. Expected ' + test[1] + ' (' + str(test[0]) + '), got ' + result + '.')
  else:
    print('Success')
    
## Voorbeeld:

# "0011" (3) + "0011" (3) = "0110" (6) 
print(int_to_bin(bin_to_int('0011') + bin_to_int('0011')))

# "1111" (15) + "0001" (1) = "00010000" (16) 
print(int_to_bin(bin_to_int('1111') + bin_to_int('0001')))