def test_Multi_to_decimel(self):
"Binary -> decimel"
"TODO -- check against negative numbers"
self.assertEquals(Multi.to_decimel(m_fifteen), 15)
self.assertEquals(Multi.to_decimel(m_eight), 8)
self.assertEquals(Multi.to_decimel(m_one), 1)
self.assertEquals(Multi.to_decimel(m_zero), 0)
def __call__(self, multi, load, address, clock):
inputs = dmux_multiway(Multi([load]), address)
regs = [
Multi(pair[0](multi, pair[1], clock))
for pair in zip(self.reg, inputs)
]
return multimux_multiway(address, *regs)
def test_Multi_pad_to_digits_with_variable_inputs(self):
"""Checks that Multi arrays are padded to the specified number of digits, instances of equal length are returned unchanged,
and that a digit that is too low will return the original Multi instances"""
three4 = Multi([zero, zero, one, one])
zero3 = Multi([zero, zero, zero])
zero4 = Multi([zero, zero, zero, zero])
one4 = Multi([zero, zero, zero, one])
self.assertEquals(tuple([str(m) for m in pad_to_digits(m_zero, 3)]),
(str(zero3), ))
self.assertEquals(tuple([str(m) for m in pad_to_digits(m_three, 4)]),
(str(three4), ))
self.assertEquals(tuple([str(m) for m in pad_to_digits(m_one, 1)]),
(str(m_one), ))
self.assertEquals(tuple([str(m) for m in pad_to_digits(m_three, 4)]),
(str(three4), ))
self.assertEquals(
tuple([str(m) for m in pad_to_digits(m_zero, 4, m_one, m_eight)]),
(str(zero4), str(one4), str(m_eight)))
self.assertEquals(
tuple([str(m) for m in pad_to_digits(m_eight, 4, m_one, m_eight)]),
(str(m_eight), str(one4), str(m_eight)))
self.assertEquals(
tuple([str(m) for m in pad_to_digits(m_fourteen, 4, m_fifteen)]),
(str(m_fourteen), str(m_fifteen)))
def test_Multi_to_decimel(self):
"Binary -> decimel"
"TODO -- check against negative numbers"
self.assertEquals(Multi.to_decimel(m_fifteen), 15)
self.assertEquals(Multi.to_decimel(m_eight), 8)
self.assertEquals(Multi.to_decimel(m_one), 1)
self.assertEquals(Multi.to_decimel(m_zero), 0)
def test_Multi_or(self):
"Checks that multibit | returns the correct value and pads Multi arrays of different sizes appropriately"
self.assertEquals(str(m_eight | m_zero), str(m_eight))
self.assertEquals(str(m_eight | m_one),
str(Multi([one, zero, zero, one])))
self.assertEquals(str(m_eight | m_fifteen), str(m_fifteen))
self.assertEquals(str(m_three | m_one), str(Multi([zero, one, one])))
self.assertEquals(str(m_one | m_fourteen), str(m_fifteen))
def test_Multi_not(self):
"Checks that the multibit ~ flips all the signs of a Multi array"
self.assertEquals(str(~m_fifteen), str(Multi([zero, zero, zero,
zero])))
self.assertEquals(str(~m_eight), str(Multi([zero, one, one, one])))
self.assertEquals(str(~m_three), str(Multi([zero, zero])))
self.assertEquals(str(~m_one), str(Multi([one, one, zero])))
self.assertEquals(str(~m_zero), str(Multi([one])))
def __call__(self, multi, load, address, clock):
input_address = Multi(address[-1:-4:-1])
reg_address = Multi(address[-4:-(len(address) + 1):-1])
inputs = dmux_multiway(Multi([load]), input_address)
regs = [
Multi(pair[0](multi, pair[1], reg_address, clock))
for pair in zip(self.reg, inputs)
]
return multimux_multiway(input_address, *regs)
def test_Multi_and(self):
"Checks that the multibit & returns the correct values and pads Multi arrays of different sizes appropriately"
zero4 = Multi([zero, zero, zero, zero])
two4 = Multi([zero, zero, one, zero])
self.assertEquals(str(m_eight & m_zero), str(zero4))
self.assertEquals(str(m_eight & m_one), str(zero4))
self.assertEquals(str(m_eight & m_fifteen), str(m_eight))
self.assertEquals(str(m_three & m_fourteen), str(two4))
self.assertEquals(str(m_one & m_three), str(m_one))
def test_Multi_not(self):
"Checks that the multibit ~ flips all the signs of a positive and negative Multi array"
self.assertEquals(str(~m_fifteen), str(Multi([zero, zero, zero, zero])))
self.assertEquals(str(~m_eight), str(Multi([zero, one, one, one])))
self.assertEquals(str(~m_three), str(Multi([zero, zero])))
self.assertEquals(str(~m_one), str(Multi([one, one, zero])))
self.assertEquals(str(~m_zero), str(Multi([one])))
self.assertEquals(str(~neg_one), str(from_num(0)))
self.assertEquals(str(~neg_four), str(from_num(3)))
self.assertEquals(str(~neg_two), str(from_num(1)))
def test_Multi_or(self):
"Checks that multibit | returns the correct value of positive and negative Multi arrays"
self.assertEquals(str(m_eight | m_zero), str(m_eight))
self.assertEquals(str(m_eight | m_one), str(Multi([one, zero, zero, one])))
self.assertEquals(str(m_eight | m_fifteen), str(m_fifteen))
self.assertEquals(str(m_three | m_one), str(Multi([zero, one, one])))
self.assertEquals(str(m_one | m_fourteen), str(m_fifteen))
self.assertEquals(str(neg_eight | m_zero), str(neg_eight))
self.assertEquals(str(m_eight | neg_one), str(neg_one))
self.assertEquals(str(neg_two | neg_three), str(neg_one))
self.assertEquals(str(neg_eight | neg_three), str(neg_three))
self.assertEquals(str(neg_two | m_two), str(neg_two))
def test_add_multi(self):
"""Tests that the addition of two Multi instances return the correct 16-bit instance
If the output has an overflow (beyond 16 bits) it is ignored"""
six16 = Multi([zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, one, one, zero])
self.assertEquals(str(add_multi(m_one, m_three)), str(four16))
self.assertEquals(str(add_multi(m_one, m_16384)), str(m_16385))
self.assertEquals(str(add_multi(m_zero, m_one)), str(one16))
self.assertEquals(str(add_multi(m_fourteen, m_one)), str(fifteen16))
self.assertEquals(str(add_multi(m_three, m_three)), str(six16))
self.assertEquals(str(add_multi(neg_eight, Multi([zero, zero, one, zero, one]))), str(neg_three))
self.assertEquals(str(add_multi(four16, neg_two)), str(two16))
self.assertEquals(str(add_multi(m_zero, neg_one)), str(neg_one))
self.assertEquals(str(add_multi(neg_two, two16)), str(zero16))
def add_multi(m1, m2):
"Adds two Multi instances by doing partial adds of the individual bits (indexed from the right), and returns a 16-bit Multi instance"
m1, m2 = pad_to_digits(16, m1, m2)
sum, carry = half_adder(m1[15], m2[15])
s = [sum]
for i in range(14, -1, -1):
sum = full_adder(
m1[i], m2[i], carry
)[0] # disjointed so that sum can use the old carry value instead of the new one
carry = full_adder(m1[i], m2[i], carry)[1]
s.append(sum)
if len(s) > 16:
assert len(s[1:]) == 16
return Multi(reversed(s[1:]))
return Multi(reversed(s))
def test_Multi_pad(self):
"Checks that Multi instances of uneven length are padded appropriately, and that instances of equal length are returned unchanged"
self.assertEquals(tuple([str(m) for m in pad_multi(m_one, m_zero)]),
(str(m_one), str(Multi([zero, zero, zero]))))
self.assertEquals(tuple([str(m) for m in pad_multi(m_zero, m_one)]),
(str(Multi([zero, zero, zero])), str(m_one)))
self.assertEquals(tuple([str(m) for m in pad_multi(m_three, m_zero)]),
(str(m_three), str(Multi([zero, zero]))))
self.assertEquals(tuple([str(m) for m in pad_multi(m_zero, m_one)]),
(str(Multi([zero, zero, zero])), str(m_one)))
self.assertEquals(tuple([str(m) for m in pad_multi(m_eight, m_one)]),
(str(m_eight), str(Multi([zero, zero, zero, one]))))
self.assertEquals(
tuple([str(m) for m in pad_multi(m_fourteen, m_fifteen)]),
(str(m_fourteen), str(m_fifteen)))
def get_encoder(type, **kargs):
"""
Creates an encoder of the appropriate type and returns an instance of it.
@param type: The type of encoder to create. The supported types are:
"unity", "threshold", "scalar", "category", and "multi".
@param kargs: Any keyword arguments to pass to the encoder.
@return: An encoder instance.
@raise UnsupportedEncoder: Raised if the requested encoder is not
supported.
"""
t = type.lower()
if t == 'unity':
return Unity(**kargs)
elif t == 'threshold':
return Threshold(**kargs)
elif t == 'scalar':
return Scalar(**kargs)
elif t == 'multi':
return Multi(**kargs)
elif t == 'category':
return Category(**kargs)
else:
raise UnsupportedEncoder(t)
def test_Multi_comparison(self):
"Checks the comparison operators (>, <, etc) on both positive and negative Multi instances"
self.assertTrue(m_fifteen != m_fourteen)
self.assertTrue(m_eight != neg_eight)
self.assertTrue(m_three == three16)
self.assertTrue(m_three == Multi([one, one]))
def alu(x, y, zx, nx, zy, ny, f, no):
"""Calculates a variety of functions on x and y, determined by the combination of control bits
Outputs (out, zr, ng) where out is the 16-bit Multi result, and zr and ng are single Bits"""
neg_one = Multi(Bit(digit) for digit in '1111111111111111')
zero_x = x & Multi(~Bit(zx) for bit in range(16))
zero_y = y & Multi(~Bit(zy) for bit in range(16))
x2 = multimux(zero_x, ~zero_x, nx)
y2 = multimux(zero_y, ~zero_y, ny)
f_xy = multimux(x2 & y2, add_multi(x2, y2), f)
out = multimux(f_xy, ~f_xy, no)
zr = ~(or_multiway(out))
ng = out[0]
return (out, zr, ng)
def run():
'''Start Running'''
menu = Menu(settings,screen)
gf.update_menu_screen(settings, screen, menu)
while gf.check_events_menu(settings,screen,menu):
gf.update_menu_screen(settings, screen, menu)
if menu.result == "Start":
game = Game(settings, screen)
gf.update_game_screen(settings,screen,game)
if settings.multiplay and not settings.multi_main:
for event in py.event.get():
pass
game.webActions(10,10)
gf.update_game_screen(settings,screen,game)
while True:
if not gf.check_events_game(settings, screen, game): break
gf.update_game_screen(settings,screen,game)
for event in py.event.get():
pass
if settings.multiplay:
game.webActions(game.tempx, game.tempy)
for event in py.event.get():
pass
gf.update_game_screen(settings,screen,game)
break
elif menu.result == "Multi":
multi = Multi(settings, screen)
gf.update_multi_screen(settings, screen, multi)
while gf.check_events_multi(settings, screen, multi):
gf.update_multi_screen(settings, screen, multi)
break
def test_Multi_and(self):
"Checks that the multibit & returns the correct values of positive and negative Multi arrays of different sizes"
zero4 = Multi([zero, zero, zero, zero])
two4 = Multi([zero, zero, one, zero])
self.assertEquals(str(m_eight & m_zero), str(zero4))
self.assertEquals(str(m_eight & m_one), str(zero4))
self.assertEquals(str(m_eight & m_fifteen), str(m_eight))
self.assertEquals(str(m_three & m_fourteen), str(two4))
self.assertEquals(str(m_one & m_three), str(m_one))
self.assertEquals(str(eight16 & neg_eight), str(eight16))
self.assertEquals(str(eight16 & neg_four), str(eight16))
self.assertEquals(str(zero16 & neg_one), str(zero16))
self.assertEquals(str(neg_three & m_fourteen), str(from_num(12)))
self.assertEquals(str(neg_one & neg_three), str(neg_three))
def test_Multi_to_decimal(self):
"Binary -> decimal for both positive and negative numbers"
self.assertEquals(Multi.to_decimal(m_fifteen), 15)
self.assertEquals(Multi.to_decimal(m_eight), 8)
self.assertEquals(Multi.to_decimal(m_one), 1)
self.assertEquals(Multi.to_decimal(m_zero), 0)
self.assertEquals(Multi.to_decimal(neg_one), -1)
self.assertEquals(Multi.to_decimal(neg_two), -2)
self.assertEquals(Multi.to_decimal(neg_three), -3)
self.assertEquals(Multi.to_decimal(neg_four), -4)
def test_multimux_multiway(self):
one4 = Multi([zero, zero, zero, one])
zero4 = Multi([zero, zero, zero, zero])
self.assertEquals(
str(multimux_multiway(Multi([one]), m_fifteen, m_fourteen)),
str(m_fourteen))
self.assertEquals(
str(
multimux_multiway(Multi([one, one]), m_fifteen, m_fourteen,
m_zero, m_one)), str(one4))
self.assertEquals(
str(
multimux_multiway(Multi([zero, one]), m_three, m_zero,
m_fifteen, m_fourteen)), str(zero4))
self.assertEquals(
str(
multimux_multiway(Multi([one, zero, zero]), m_zero, m_three,
m_fourteen, m_eight, m_one, m_zero,
m_fifteen, m_fourteen)), str(m_eight))
self.assertEquals(
str(
multimux_multiway(Multi([zero, one, zero]), m_zero, m_three,
m_fourteen, m_eight, m_one, m_zero,
m_fifteen, m_fourteen)), str(m_fourteen))
def add_multi(m1, m2):
m1, m2 = m1.pad_to_digits(m2, 16)
carry = half_adder(m1[-1], m2[-1])[1]
s = []
for i in range(len(m1) - 1):
carry = full_adder(m1[i], m2[i], carry)[1]
s.append(full_adder(m1[i + 1], m2[i + 1], carry)[0])
return Multi(s)
def test_multimux(self):
zero3 = Multi([zero, zero, zero])
self.assertEquals(str(multimux(m_eight, m_zero, zero)), str(m_eight))
self.assertEquals(str(multimux(m_eight, m_fifteen, one)),
str(m_fifteen))
self.assertEquals(str(multimux(m_zero, m_one, zero)), str(zero3))
self.assertEquals(str(multimux(m_zero, m_one, one)), str(m_one))
def save_pre(n, pre_prob):
if None in (n, pre_prob):
raise PreventUpdate
if pre_prob == 'trav':
configs.params['prob_type'] = Single(configs.params)
configs.params['num_objs'] = 1
configs.params['objs'] = [min]
configs.params['obj_names'] = ['Distance']
configs.params['enc_name'] = 'Permutation'
configs.params['enc_type'] = Perm(configs.params)
configs.params['gene_size'] = 29
configs.params['enc_type'].params['min_value'] = 0
configs.params['enc_type'].params['max_value'] = 28
configs.params['eval_type'] = TSP
configs.params['cust_vis'] = network
elif pre_prob == 'knap':
configs.params['prob_type'] = Multi(configs.params)
configs.params['num_objs'] = 2
configs.params['objs'] = [max, min]
configs.params['obj_names'] = ['Value', 'Weight']
configs.params['enc_name'] = 'Binary String'
configs.params['enc_type'] = Binary(configs.params)
configs.params['gene_size'] = 64
configs.params['enc_type'].params['min_value'] = 0
configs.params['enc_type'].params['max_value'] = 1
configs.params['eval_type'] = knapsack
configs.params['cust_vis'] = selection
configs.params['n'] = 8
elif pre_prob == 'queens':
configs.params['prob_type'] = Single(configs.params)
configs.params['num_objs'] = 1
configs.params['objs'] = [min]
configs.params['obj_names'] = ['Threats']
configs.params['enc_name'] = 'Permutation'
configs.params['enc_type'] = Perm(configs.params)
configs.params['gene_size'] = 64
configs.params['enc_type'].params['min_value'] = 0
configs.params['enc_type'].params['max_value'] = 63
configs.params['eval_type'] = eight_queens
configs.params['cust_vis'] = chess_board
elif pre_prob == 'sudoku':
configs.params['prob_type'] = Single(configs.params)
configs.params['num_objs'] = 1
configs.params['objs'] = [min]
configs.params['obj_names'] = ['Conflicts']
configs.params['enc_name'] = 'Permutation'
configs.params['enc_type'] = Perm(configs.params)
configs.params['gene_size'] = 100
configs.params['enc_type'].params['min_value'] = 0
configs.params['enc_type'].params['max_value'] = 99
configs.params['eval_type'] = sudoku
configs.params['cust_vis'] = sudoku_board
return 'Saved'
def save(n, prob_type, num_objs, obj_1_name, obj_2_name, obj_3_name,
obj_1_goal, obj_2_goal, obj_3_goal, enc_type, gene_size,
min_value, max_value):
if None in (n, prob_type, num_objs, min_value, max_value):
raise PreventUpdate
elif num_objs == 1 and None in (obj_1_name, obj_1_goal):
raise PreventUpdate
elif num_objs == 2 and None in (obj_1_name, obj_1_goal, obj_2_name,
obj_2_goal):
raise PreventUpdate
elif num_objs == 3 and None in (obj_1_name, obj_1_goal, obj_2_name,
obj_2_goal, obj_3_name, obj_3_goal):
raise PreventUpdate
elif gene_size is not None and gene_size < 0:
raise PreventUpdate
elif min_value is not None and min_value >= max_value:
raise PreventUpdate
elif max_value is not None and max_value <= min_value:
raise PreventUpdate
if prob_type == 'sing-obj':
configs.params['prob_type'] = Single(configs.params)
else:
configs.params['prob_type'] = Multi(configs.params)
configs.params['num_objs'] = num_objs
configs.params['objs'], configs.params['obj_names'] = [], []
dirs, names = [obj_1_goal, obj_2_goal,
obj_3_goal], [obj_1_name, obj_2_name, obj_3_name]
for i in range(configs.params['num_objs']):
if dirs[i] == 'min':
configs.params['objs'].append(min)
else:
configs.params['objs'].append(max)
configs.params['obj_names'].append(names[i])
if enc_type == 'perm':
configs.params['enc_name'] = 'Permutation'
configs.params['enc_type'] = Perm(configs.params)
elif enc_type == 'binary':
configs.params['enc_name'] = 'Binary String'
configs.params['enc_type'] = Binary(configs.params)
elif enc_type == 'int':
configs.params['enc_name'] = 'Integer String'
configs.params['enc_type'] = Integer(configs.params)
elif enc_type == 'real':
configs.params['enc_name'] = 'Real-Valued String'
configs.params['enc_type'] = Real(configs.params)
configs.params['gene_size'] = gene_size
configs.params['enc_type'].params['min_value'] = min_value
configs.params['enc_type'].params['max_value'] = max_value
return 'Saved'
def __call__(self, multi, load, increase, reset, clock):
# if load, inc, or reset are set, load should be set for the register
reg_load = load | increase | reset
# if inc = 1, return (value + 1), else return value
if_increase = multimux(self.value, inc(self.value), increase)
# if load = 1, return multi, else return if_increase
if_out = multimux(if_increase, multi, load)
# if reset = 1, return 0, else return if_out
if_reset = multimux(if_out, Multi(zero for i in range(16)), reset)
self.value = self.reg(if_reset, reg_load, clock)
return self.value
def test_multimux(self):
"Checks that multimux(a, b) -> a if sel = 0, and b if sel = 1"
zero3 = Multi([zero, zero, zero])
self.assertEquals(str(multimux(m_eight, m_zero, zero)), str(m_eight))
self.assertEquals(str(multimux(m_eight, m_fifteen, one)), str(m_fifteen))
self.assertEquals(str(multimux(m_zero, m_one, zero)), str(zero3))
self.assertEquals(str(multimux(m_zero, m_one, one)), str(m_one))
self.assertEquals(str(multimux(neg_one, m_zero, zero)), str(neg_one))
self.assertEquals(str(multimux(m_eight, neg_two, one)), str(neg_two))
self.assertEquals(str(multimux(m_zero, neg_one, zero)), str(zero16))
self.assertEquals(str(multimux(neg_one, m_one, one)), str(one16))
def test_multimux_multiway(self):
"""Checks that multimux_multiway returns the correct value given an input of 2, 4, or 8 Multi instances
and a corresponding selector of 1, 2, or 3 digits"""
one4 = Multi([zero, zero, zero, one])
zero4 = Multi([zero, zero, zero, zero])
self.assertEquals(str(multimux_multiway(Multi([one]), m_fifteen, m_fourteen)), str(m_fourteen))
self.assertEquals(str(multimux_multiway(Multi([zero]), neg_one, m_fourteen)), str(neg_one))
self.assertEquals(str(multimux_multiway(Multi([one, one]), m_fifteen, neg_two, m_zero, m_one)), str(one16))
self.assertEquals(str(multimux_multiway(Multi([zero, one]), m_zero, neg_one, m_two, neg_three)), str(neg_one))
self.assertEquals(str(multimux_multiway(Multi([one, zero, zero]), m_zero, neg_one, m_fourteen, neg_eight, m_one, m_zero,
m_fifteen, neg_three)), str(one16))
self.assertEquals(str(multimux_multiway(Multi([zero, one, zero]), m_zero, m_three, m_fourteen, m_eight, m_one, m_zero,
m_fifteen, m_fourteen)), str(m_fourteen))
def test_alu(self):
x = zero16
y = neg_one
self.assertEquals([str(bit) for bit in alu(x, y, one, zero, one, zero, one, zero)], [str(zero16), str(one), str(zero)]) # 0
self.assertEquals([str(bit) for bit in alu(x, y, one, one, one, one, one, one)], [str(one16), str(zero), str(zero)]) # 1
self.assertEquals([str(bit) for bit in alu(x, y, one, one, one, zero, one, zero)], [str(neg_one), str(zero), str(one)]) # -1
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, zero, zero)], [str(zero16), str(one), str(zero)]) # x
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, zero, zero)], [str(neg_one), str(zero), str(one)]) # y
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, zero, one)], [str(neg_one), str(zero), str(one)]) # ~x
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, zero, one)], [str(zero16), str(one), str(zero)]) # ~y
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, one, one)], [str(zero16), str(one), str(zero)]) # -x
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, one, one)], [str(one16), str(zero), str(zero)]) # -y
self.assertEquals([str(bit) for bit in alu(x, y, zero, one, one, one, one, one)], [str(one16), str(zero), str(zero)]) # x + 1
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, one, one, one)], [str(zero16), str(one), str(zero)]) # y + 1
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, one, zero)], [str(neg_one), str(zero), str(one)]) # x - 1
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, one, zero)], [str(neg_two), str(zero), str(one)]) # y - 1
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, zero, zero, one, zero)], [str(neg_one), str(zero), str(one)]) # x + y
self.assertEquals([str(bit) for bit in alu(x, y, zero, one, zero, zero, one, one)], [str(one16), str(zero), str(zero)]) # x - y
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, zero, one, one, one)], [str(neg_one), str(zero), str(one)]) # y - x
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, zero, zero, zero, zero)], [str(zero16), str(one), str(zero)]) # x & y
self.assertEquals([str(bit) for bit in alu(x, y, zero, one, zero, one, zero, one)], [str(neg_one), str(zero), str(one)]) # x | y
x = Multi(from_num(17))
y = three16
self.assertEquals([str(bit) for bit in alu(x, y, one, zero, one, zero, one, zero)], [str(zero16), str(one), str(zero)]) # 0
self.assertEquals([str(bit) for bit in alu(x, y, one, one, one, one, one, one)], [str(one16), str(zero), str(zero)]) # 1
self.assertEquals([str(bit) for bit in alu(x, y, one, one, one, zero, one, zero)], [str(neg_one), str(zero), str(one)]) # -1
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, zero, zero)], [str(x), str(zero), str(zero)]) # x
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, zero, zero)], [str(y), str(zero), str(zero)]) # y
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, zero, one)], [str(~x), str(zero), str(one)]) # ~x
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, zero, one)], [str(~y), str(zero), str(one)]) # ~y
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, one, one)], [str(from_num(-17)),
str(zero), str(one)]) # -x
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, one, one)], [str(neg_three), str(zero), str(one)]) # -y
self.assertEquals([str(bit) for bit in alu(x, y, zero, one, one, one, one, one)], [str(inc(x)), str(zero), str(zero)]) # x + 1
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, one, one, one)], [str(inc(y)), str(zero), str(zero)]) # y + 1
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, one, one, one, zero)], [str(from_num(16)),
str(zero), str(zero)]) # x - 1
self.assertEquals([str(bit) for bit in alu(x, y, one, one, zero, zero, one, zero)], [str(two16), str(zero), str(zero)]) # y - 1
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, zero, zero, one, zero)], [str(from_num(20)),
str(zero), str(zero)]) # x + y
self.assertEquals([str(bit) for bit in alu(x, y, zero, one, zero, zero, one, one)], [str(from_num(14)),
str(zero), str(zero)]) # x - y
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, zero, one, one, one)], [str(from_num(-14)),
str(zero), str(one)]) # y - x
self.assertEquals([str(bit) for bit in alu(x, y, zero, zero, zero, zero, zero, zero)], [str(one16), str(zero), str(zero)]) # x & y
self.assertEquals([str(bit) for bit in alu(x, y, zero, one, zero, one, zero, one)], [str(from_num(19)),
str(zero), str(zero)]) # x | y
class Comment:
content: str
extension: str
single: Single
multi: Multi
todo: TODO
def __init__(self, content, extension):
self.content = content
self.extension = extension
self.single = Single(self.content, self.extension)
self.multi = Multi(self.content, self.extension)
self.todo = TODO(self.content)
def singleLines(self):
singles = self.single.lines()
multiSingles = self.single.multiSingleLines()
falsePositives = self.single.falsePositivesLines(
) #special case pattern for single false positives
return str(singles - multiSingles - falsePositives)
def blockComments(self):
blocks = self.multi.blocks()
multiSingleBlocks = int(self.single.multiSingleBlocks())
return str(blocks + multiSingleBlocks)
def blockLines(self):
lines = self.multi.lines()
multiSingleLines = self.single.multiSingleLines()
return str(lines + multiSingleLines)
def commentLines(self):
return str(int(self.singleLines()) + int(self.blockLines()))
def TODOLines(self):
return str(int(self.todo.lines()))
def from_num(num):
"Helper function to create a 16-bit Multi instance using a number"
bnum = bin(num)
b = bnum.index('b') + 1
pos = Multi(Bit(digit) for digit in bnum[b:])
pos.insert(0, Bit(0))
pos = pad_to_digits(16, pos)[0]
if bnum[0] == '-':
neg = inc(~pos)
if len(neg) > 16:
return neg[1:]
return Multi(neg)
return Multi(pos)
def test_Multi_pad(self):
"""Checks that positive and negative Multi instances of uneven length are padded appropriately.
Also checks that instances of equal length are returned unchanged"""
neg_one5 = Multi([one, one, one, one, one])
neg_two6 = Multi([one, one, one, one, one, zero])
neg_three8 = Multi([one, one, one, one, one, one, zero, one])
self.assertEquals(tuple([str(m) for m in pad_multi(m_one, m_zero)]), (str(m_one), str(Multi([zero, zero, zero]))))
self.assertEquals(tuple([str(m) for m in pad_multi(m_zero, m_one)]), (str(Multi([zero, zero, zero])), str(m_one)))
self.assertEquals(tuple([str(m) for m in pad_multi(m_three, m_zero)]), (str(m_three), str(Multi([zero, zero]))))
self.assertEquals(tuple([str(m) for m in pad_multi(m_zero, m_one)]), (str(Multi([zero, zero, zero])), str(m_one)))
self.assertEquals(tuple([str(m) for m in pad_multi(m_eight, m_one)]), (str(m_eight), str(Multi([zero, zero, zero, one]))))
self.assertEquals(tuple([str(m) for m in pad_multi(m_fourteen, m_fifteen)]), (str(m_fourteen), str(m_fifteen)))
self.assertEquals(tuple([str(m) for m in pad_multi(neg_one5, m_zero)]), (str(neg_one5), str(Multi([zero, zero, zero, zero, zero]))))
self.assertEquals(tuple([str(m) for m in pad_multi(m_zero, neg_one5)]), (str(Multi([zero, zero, zero, zero, zero])), str(neg_one5)))
self.assertEquals(tuple([str(m) for m in pad_multi(neg_three8, neg_one5)]), (str(neg_three8),
str(Multi([one, one, one, one, one, one, one, one]))))
self.assertEquals(tuple([str(m) for m in pad_multi(neg_two6, neg_three8)]), (str(Multi([one, one, one, one, one, one, one, zero])),
str(Multi([one, one, one, one, one, one, zero, one]))))
self.assertEquals(tuple([str(m) for m in pad_multi(neg_two6, m_fourteen)]), (str(neg_two6),
str(Multi([zero, zero, one, one, one, zero]))))
