100-Bit Binary Ripple-Carry Adder Implementation in Python

This Python code demonstrates the implementation of a 100-bit binary ripple-carry adder using 100 full adders. It takes two 100-bit binary numbers and a carry-in, producing a 100-bit sum and outputs carry-out values from each full adder.

def full_adder(a, b, carry_in):
    sum_ = (a ^ b) ^ carry_in
    carry_out = (a & b) | ((a ^ b) & carry_in)
    return sum_, carry_out

def ripple_carry_adder(a, b, carry_in):
    sum_ = []
    carry_out = []
    for i in range(100):
        bit_sum, carry_in = full_adder(a[i], b[i], carry_in)
        sum_.append(bit_sum)
        carry_out.append(carry_in)
    return sum_, carry_out

# Example usage
a = [1, 0, 1, 0, ...]  # 100-bit binary number
b = [0, 1, 1, 0, ...]  # 100-bit binary number
carry_in = 0  # Carry-in value

sum_, carry_out = ripple_carry_adder(a, b, carry_in)

print('Sum:', sum_)  # 100-bit sum
print('Carry-out:', carry_out)  # Carry-out from each full adder
print('Final Carry-out (cout[99]):', carry_out[99])  # Final carry-out

The full_adder function takes three inputs: a, b, and carry_in, and returns both the sum and the carry-out for a single bit. The ripple_carry_adder function utilizes the full_adder function to perform addition bit by bit for the given 100-bit numbers a and b, along with the carry-in value. It returns the resulting sum and the carry-out from each full adder.

Please note that the a and b inputs should be lists of length 100, representing the 100-bit numbers, where each element is either 0 or 1. The carry_in input should be either 0 or 1.