def new_decoder(number_ins, is_dual):
ins = []
for index in range(number_ins):
ins.append('in_'+str(index))
number_outs = power(number_ins)
outs = []
for index in range(number_outs):
outs.append('o_'+str(index))
return new_boolean(ins,outs, decoder_truth, 'decoder_'+str(number_ins))
def new_mux_bad(number_selects, is_dual=False, in_pre='in', select_pre='select', out='out'):
number_ins = power(number_selects)
ins = []
for index in range(number_ins):
ins.append('in_'+str(index))
for index in range(number_selects):
ins.append('select_'+str(index))
outs = ['out']
return new_boolean(ins,outs, mux_truth, 'mux_'+str(number_ins))
def new_tree_mux_help(select_sets, devices, wires, level, index=0, parent_index=0):
select_set = select_sets[level]
number_selects = len(select_set)
num_ins = power(number_selects)
sindex = str(index)
parent_name = 'mux_'+str(level+1)+'_'+str(parent_index)
if (level <= -1):
# create input links
ins_per_zero = power(len(select_sets[0]))
parent_in = index%ins_per_zero
in_name = 'in'+sindex
append_bridge(devices, in_name)
wire = set_wire(wires, 'wire_'+in_name,[in_name],[parent_name+'/in'+str(parent_in)])
return
name = 'mux_'+str(level)+'_'+str(index)
mux = {
'type': 'mux'+str(number_selects),
'name': name
}
# now hookup selects to device selects.
for idx, select in enumerate(select_set):
wire = wires['wire_'+select]
wire['to'].append(name+'/select'+str(idx))
# wire from output to parent's input
if level >= len(select_sets) - 1:
#parent set.
append_bridge(devices, 'out')
set_wire(wires, 'wire_'+name, [name+'/out'], ['out'])
else:
set_wire(wires, 'wire_'+name, [name+'/out'], [parent_name+'/in'+str(index)])
devices.append(mux)
child_range = [index*num_ins, (index+1)*num_ins]
for child_index in range(*child_range):
new_tree_mux_help(select_sets, devices, wires, level-1, child_index, index)
def get_selects(total):
'''
inputs = 2^selects
2^selects + selects = total
'''
current = 0
selects = 1
while(True):
current = power(selects) + selects
if current >= total:
break
selects += 1
return selects
def new_tree_decoder_help(ranges, devices, wires, parent_index=0, level=0, index=0):
sindex = str(index)
'''
Root parent is one decoder and starts at level 0.
Ranges is a list of input index i.e [(0,2),(2,6)]
'''
# if not root, create wire from parent to self.
if level>0:
sparentl = str(parent_index)
ins_per_parent = ranges[level-1][1] - ranges[level-1][0]
outs_per_parent = power(ins_per_parent)
out_index = index %outs_per_parent
parent_name = 'decoder_'+str(level-1)+'_'+ sparentl+'/out'+str(out_index)
wire_name = 'wiredecoder'+str(level-1)+'_'+ sparentl
set_wire(wires, wire_name, [parent_name],[])
wire = wires[wire_name]
# if past last level, make outputs
if level >= len(ranges):
# write outputs
out_name = 'out'+str(index)
append_bridge(devices, out_name)
wire['to'].append(out_name)
return
in_range = ranges[level]
num_ins= in_range[1] - in_range[0]
slevel = str(level)
num_outs = power(num_ins)
# wire from parent output
name = 'decoder_'+slevel+'_'+sindex
# level < end
decoder = {
'type': 'decoder'+str(num_ins),
'name': name
}
devices.append(decoder)
if level>0:
for idx, offset in enumerate(range(*in_range)):
i = str(idx)
soff = str(offset)
and_name = 'and_'+slevel+'_'+sindex+'_'+i
and_device = new_device(and_name, 'and2')
devices.append(and_device)
wire['to'].append(and_name+'/in0')
in_name = 'in'+ soff
in_wire = wires['wire'+in_name]
in_wire['to'].append(and_name+'/in1')
set_wire(wires, 'wire'+and_name, [and_name+'/out'], [name+'/in'+i])
else:
# root level. input to decoder input
for offset in range(*in_range):
in_name = 'in'+ str(offset)
in_wire = wires['wire'+in_name]
in_wire['to'].append(name+'/in'+str(offset))
child_range = [index*num_outs, (index+1)*num_outs]
for child_index in range(*child_range):
new_tree_decoder_help(ranges, devices, wires, index, level+1, child_index)
