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 __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_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 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_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 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_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 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_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 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 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 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 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 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 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
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]))))
def test_falsePositive(self): string = "print(\'\'\' Hello \'\'\')" test = Multi(string,"py") output = test.lines() self.assertEqual(1, output)
def test_numOfMultiLineComments(self): string = "\'\'\'\nComment\n\'\'\'" test = Multi(string,"py") output = test.lines() self.assertEqual(3, output)
def test_multiLineCommentsWithNewLines(self): string = "\'\'\'\nComment\n\'\'\'" test = Multi(string,"py") output = test.blocks() self.assertEqual(1, output)