Pipon Ripple carry Adder?

Question

В настоящее время я делаю проект в моем классе дискретной математики, и мы должны код:

1.) RippleCarryAdder: это схема для добавления фиксированного размера, 5-битовые целые числа. Параметры:

x_array: operand 1, i.e. an array of 5 wires 
y_array: operand 2, i.e. an array of 5 wires 
s_array: sum, i.e. an array of 6 wires 

2.) RippleCarryAdder: это схема для добавления п-битовых чисел. Параметры:

x_array: operand 1, i.e. an array of n wires 
y_array: operand 2, i.e. an array of n wires 
s_array: sum, i.e. an array of (n+1) wires 

Я уже закодированы половину и полный сумматор.

Я понимаю основную концепцию Ripple Carry. Мне просто сложно сбрасывать код. Любая помощь будет оценена!

Код:

#!/usr/bin/python3 

import unittest 
from digital_circuit_core import * 

class InputLengthException(Exception): pass 

class MyPrettySimulator(Simulator): 

def HalfAdder(self, a, b, s, c): 
    # internal wires 
    d = self.Wire('d-wire') 
    e = self.Wire('e-wire') 

    self.OrGate(a, b, d) 
    self.AndGate(a, b, c) 
    self.Inverter(c, e) 
    self.AndGate(d, e, s) 

    return 'ok' 


def FullAdder(self, a, b, c_in, s, c_out): 
    # internal wires 
    d = self.Wire() 
    c1 = self.Wire() 
    c2 = self.Wire() 

    self.HalfAdder(b, c_in, d, c1) 
    self.HalfAdder(a, d, s, c2) 
    self.OrGate(c1, c2, c_out)  

    return 'ok' 

def RippleCarryAdder_5_bits(self, x_array, y_array, s_array): 

    ############# YOUR CODE HERE ############### 

    return 'ok' 

def RippleCarryAdder(self, x_arr, y_arr, s_arr): 

    ############ YOUR CODE HERE ############ 

    return 'ok' 

Answer 1

Пять сумматор должен быть довольно легко, вы просто склеить одну половину сумматор и 4 полных сумматоров:

def RippleCarryAdder_5_bits(self, x_array, y_array, s_array): 
    # internal wires 
    c0 = self.Wire() 
    c1 = self.Wire() 
    c2 = self.Wire() 
    c3 = self.Wire() 

    self.HalfAdder(x_array[0], y_array[0], s_array[0], c0) 
    self.FullAdder(x_array[1], y_array[1], c0, s_array[1], c1) 
    self.FullAdder(x_array[2], y_array[2], c1, s_array[2], c2) 
    self.FullAdder(x_array[3], y_array[3], c2, s_array[3], c3) 
    self.FullAdder(x_array[4], y_array[4], c3, s_array[4], s_array[5]) 

    return 'ok' 

версия неограниченный размер, по существу, то же самое , вы просто используете цикл, чтобы вы могли обрабатывать неограниченное количество бит, а не жесткое кодирование определенного числа:

def RippleCarryAdder(self, x_arr, y_arr, s_arr): 
    # handle first bit manually 
    carry_out = self.Wire() 
    self.HalfAdder(x_array[0], y_array[0], s_array[0], carry_out) 

    # handle all middle bits with a loop 
    for x, y, s in zip(x_arr[1:-1], y_arr[1:-1], s_arr[1:-2]): 
     carry_in = carry_out 
     carry_out = self.Wire() 
     self.FullAdder(x, y, carry_in, s, carry_out) 

    # handle last bit manually too 
    self.FullAdder(x_array[-1], y_array[-1], carry_out, s_array[-2], s_array[-1]) 

    return 'ok' 

Возможно, вы могли бы сделать логику проще, если хотите. Вы можете использовать цикл для всех бит, если бы вы могли перенести всегда нулевой провод carry_in на первый, и если бы был простой способ подключить окончательный carry_out для подключения к s_array[-1] (я думаю, OrGate с тем же вводом дважды может работать для последних).