def getoutput(self):
Ai, Bi = self.signal
ab = And((Ai, Not(Bi)))
ba = And((Not(Ai), Bi))
signal = (ab, ba)
aisb = Nor(signal)
self.output = (ab, aisb, ba)
return self.output
def getoutput(self):
a, b, bwin = self.signal
d = Xor((Xor((a, b)), bwin))
bpa = And((bwin, b))
bpb = And((b, Not(a)))
bpc = And((bwin, Not(a)))
bout = Or((Or((bpa, bpb)), bpc))
return(bout, d)
def getoutput(self):
data, enabled = self.signal
r = Not(data)
s = data
self.gatedlatch.setinput((r, s, enabled))
self.output = self.gatedlatch.getoutput()
return self.output
def getoutput(self):
data, enabled = self.signal
r = Not(data)
s = data
signal = (r, s)
self.latch.setinput(signal)
self.output = self.latch.getoutput()
return self.output
def getoutput(self):
data, clock = self.signal
self.master.setinput(self.signal)
data, qn = self.master.getoutput()
clock = Not(clock)
signal = (data, clock)
self.slave.setinput(signal)
self.output = self.slave.getoutput()
return self.output
def getoutput(self):
j, k, clock = self.signal
q, qn = self.output
k = Not(k)
ora = And((j, qn))
orb = And((k, q))
signal = (ora, orb)
d = Or(signal)
signal = (d, clock)
self.flipflop.setinput(signal)
self.output = self.flipflop.getoutput()
return tuple(self.output)
def getoutput(self):
a, b, Enable = self.signal
output = []
signal = (Not(a), Not(b), Enable)
d0 = And(signal)
output.append(d0)
signal = (a, Not(b), Enable)
d1 = And(signal)
output.append(d1)
signal = (Not(a), b, Enable)
d2 = And(signal)
output.append(d2)
signal = (a, b, Enable)
d3 = And(signal)
output.append(d3)
self.output = tuple(output)
return self.output
def getoutput(self):
a, b, ca, Enable = self.signal
output = []
# last one first because of order enabled.
signal = (a, b, Not(ca))
self.decoder2.setinput(signal)
output += self.decoder2.getoutput()
signal = (a, b, ca)
self.decoder1.setinput(signal)
output += self.decoder1.getoutput()
# output if enabled
for i, bit in enumerate(output):
output[i] = And((bit, Enable))
self.output = tuple(output)
return(self.output)
def getoutput(self):
ai = self.Ai
bi = self.Bi
Gi, Ei, Li = self.previous
previous = (Gi, Not(Ei), Li)
signal = (appendTuple((ai[0], bi[0]), previous))
self.comp1.setinput(signal)
previous = self.comp1.getoutput()
signal = (appendTuple((ai[1], bi[1]), previous))
self.comp2.setinput(signal)
previous = self.comp2.getoutput()
signal = (appendTuple((ai[2], bi[2]), previous))
self.comp3.setinput(signal)
previous = self.comp3.getoutput()
signal = (appendTuple((ai[3], bi[3]), previous))
self.comp4.setinput(signal)
output = self.comp4.getoutput()
self.output = output
return self.output
def getoutput(self):
ei, d0, d1, d2, d3, d4, d5, d6, d7 = self.signal
output = []
signal = (d0, d1, d2, d3, d4, d5, d6, d7, Not(ei))
eo = Nand(signal)
signal = (Not(eo), ei)
g5 = Or(signal)
# doing the inputs for A0
signal = (Not(d1), d2, d4, d6, Not(ei))
a = And(signal)
signal = (Not(d3), d4, d6, Not(ei))
b = And(signal)
signal = (Not(d5), d6, Not(ei))
c = And(signal)
signal = (Not(d7), Not(ei))
d = And(signal)
signal = (a, b, c, d)
a0 = Nor(signal)
# doing the inputs for A1
signal = (Not(d2), d4, d5, Not(ei))
a = And(signal)
signal = (Not(d3), d4, d2, Not(ei))
b = And(signal)
signal = (Not(d6), Not(ei))
c = And(signal)
signal = (Not(d7), Not(ei))
d = And(signal)
signal = (a, b, c, d)
a1 = Nor(signal)
# doint the inputs for A2
signal = (Not(d4), Not(ei))
a = And(signal)
signal = (Not(d5), Not(ei))
b = And(signal)
signal = (Not(d6), Not(ei))
c = And(signal)
signal = (Not(d7), Not(ei))
d = And(signal)
signal = (a, b, c, d)
a2 = Nor(signal)
output = (a0, a1, a2, g5, eo)
self.output = output
return self.output
def getoutput(self):
# Bwi borrow in.
a, b = self.signal
d = Xor((a, b))
b = And((Not(a), b))
return (b, d)