def test_equal(self):
to_bag = [random.randrange(1, 11) for i in range(1000)]
bag1 = Bag(to_bag)
bag2 = Bag(to_bag)
self.assertEqual(bag1, bag2, "Bags are not equal.")
bag1.remove(to_bag[0])
self.assertNotEqual(bag1, bag2, "Bags should not be equal.")
class Digraph():
def __init__(self, V: int):
self._V = V
self._E = 0
self._adj = Bag()
for v in range(V):
self._adj.add(Bag())
@property
def V(self):
return self._V
@property
def E(self):
return self._E
def addEdge(self, v: int, w: int):
self._adj[v].add(w)
self._E += 1
return self
def adj(self, v) -> iter:
return self._adj[v]
def reverse(self):
R = Digraph(self._V)
for v in range(self._V):
for w in self._adj:
R.addEdge(w, v)
return R
def test_add(self):
print('Checking for add')
bag1 = Bag([random.randint(1,10) for i in range(1000)])
bag2 = Bag()
for el in iter(bag1):
bag2.add(el)
self.assertEqual(bag1,bag2, 'bag1 and bag 2 must be equal after adding all terms')
def deliver(instructions,
meta_requests,
db_connection_info=MongoConnectionInfo()):
"""deliver artifacts defined by each of meta_requests then apply unbox instructions to each."""
created_files = []
connected_bag = Bag(db_connection_info)
if isinstance(meta_requests, dict):
print('metarequest is a dict, let make a list!')
meta_requests = [meta_requests]
direct_requirements = [dependencies.Requirement(r) for r in meta_requests]
meta_request = [dr.meta_request() for dr in direct_requirements]
meta_requests, gr = connected_bag.requirements_discover(
direct_requirements)
print('results from bag: ' + str(meta_requests) + ' ' + str(gr))
if isinstance(meta_requests, list):
for r in meta_requests:
print("REQUIRE> " + str(r))
created_files += deliver_one(instructions,
r,
db_connection_info=db_connection_info)
else:
print("REQUIRE FAILS> " + str(meta_requests))
return [s.replace('\\', '/') for s in created_files], gr
def __init__(self):
pygame.init()
# Control how held keys are repeated
pygame.key.set_repeat(100, 100)
resolution = (799, 705)
# The window can be resized
self.window = pygame.display.set_mode(resolution, pygame.RESIZABLE)
# Window title
pygame.display.set_caption("MacGyver")
self.images = {
"floor_image":
pygame.image.load("media/floor.png").convert_alpha(),
"wall_image":
pygame.image.load("media/wall.png").convert_alpha(),
"tube_image":
pygame.image.load("media/tube.png").convert_alpha(),
"seringue_image":
pygame.image.load("media/seringue.png").convert_alpha(),
"needle_image":
pygame.image.load("media/needle.png").convert_alpha(),
"guardian_image":
pygame.image.load("media/guardian.png").convert_alpha(),
"ether_image":
pygame.image.load("media/ether.png").convert_alpha(),
"mac_image":
pygame.image.load("media/mac.png").convert_alpha()
}
self.font = pygame.font.SysFont("herculanum", 35)
self.bag = Bag()
self.restart()
self.run()
def test_this_and_that(self):
self.assert_(2 == len(self.fake_dict.keys()))
cat_hits = self.fake_dict[Bag("cat")]
self.assert_(2 == len(cat_hits))
self.assert_(cat_hits == set(["cat", "tac"]))
self.assert_(1 == len(self.fake_dict[Bag("fred")]))
self.assert_(self.fake_dict[Bag("fred")] == set(["fred"]))
def info_cmd(argv):
parser = optparse.OptionParser(usage='rosbag info [options] BAGFILE1 [BAGFILE2 BAGFILE3 ...]',
description='Summarize the contents of one or more bag files.')
parser.add_option('-y', '--yaml', dest='yaml', default=False, action='store_true', help='print information in YAML format')
parser.add_option('-k', '--key', dest='key', default=None, action='store', help='print information on the given key')
parser.add_option( '--freq', dest='freq', default=False, action='store_true', help='display topic message frequency statistics')
(options, args) = parser.parse_args(argv)
if len(args) == 0:
parser.error('You must specify at least 1 bag file.')
if options.key and not options.yaml:
parser.error('You can only specify key when printing in YAML format.')
for i, arg in enumerate(args):
try:
b = Bag(arg, 'r', skip_index=not options.freq)
if options.yaml:
info = b._get_yaml_info(key=options.key)
if info is not None:
print info
else:
print b
b.close()
if i < len(args) - 1:
print '---'
except ROSBagUnindexedException, ex:
print >> sys.stderr, 'ERROR bag unindexed: %s. Run rosbag reindex.' % arg
except ROSBagException, ex:
print >> sys.stderr, 'ERROR reading %s: %s' % (arg, str(ex))
def info_cmd(argv):
parser = optparse.OptionParser(usage='rosbag info [options] BAGFILE1 [BAGFILE2 BAGFILE3 ...]',
description='Summarize the contents of one or more bag files.')
parser.add_option('-y', '--yaml', dest='yaml', default=False, action='store_true', help='print information in YAML format')
parser.add_option('-k', '--key', dest='key', default=None, action='store', help='print information on the given key')
parser.add_option( '--freq', dest='freq', default=False, action='store_true', help='display topic message frequency statistics')
(options, args) = parser.parse_args(argv)
if len(args) == 0:
parser.error('You must specify at least 1 bag file.')
if options.key and not options.yaml:
parser.error('You can only specify key when printing in YAML format.')
for i, arg in enumerate(args):
try:
b = Bag(arg, 'r', skip_index=not options.freq)
if options.yaml:
info = b._get_yaml_info(key=options.key)
if info is not None:
print info
else:
print b
b.close()
if i < len(args) - 1:
print '---'
except ROSBagUnindexedException, ex:
print >> sys.stderr, 'ERROR bag unindexed: %s. Run rosbag reindex.' % arg
except ROSBagException, ex:
print >> sys.stderr, 'ERROR reading %s: %s' % (arg, str(ex))
def test_add(self):
alist = [random.randint(1,10) for i in range(1000)]
b1 = Bag(alist)
random.shuffle(alist)
b2 = Bag()
for v in alist:
b2.add(v)
self.assertEqual(b1,b2)
def test_add(self):
vals = [random.randint(1, 10) for i in range(1000)]
bag1 = Bag(vals)
random.shuffle(vals)
bag2 = Bag()
for item in vals:
bag2.add(item)
self.assertEqual(bag1, bag2, 'bags are not equal')
def test_equal(self):
test = [random.randint(1, 10) for _ in range(1000)]
bag1 = Bag(test)
random.shuffle(test)
bag2 = Bag(test)
self.assertEqual(bag1, bag2)
bag1.remove(test[0])
self.assertNotEqual(bag1, bag2)
def test_add(self):
test = [random.randint(1, 10) for _ in range(1000)]
bag1 = Bag(test)
bag2 = Bag()
random.shuffle(test)
for v in test:
bag2.add(v)
self.assertEqual(bag1, bag2)
def test__eq__(self):
l = [random.randint(1, 10) for i in range(1000)]
first = Bag(l)
random.shuffle(l)
second = Bag(l)
assert first == second
first.remove(l[0])
assert first != second
def deliver_one(instructions,
meta_request,
db_connection_info=MongoConnectionInfo()):
connected_bag = Bag(db_connection_info)
package = connected_bag.take(meta_request)
package_content = io.BytesIO(package)
return gz_unbox(unbox_instructions=instructions, mem=package_content)
def test_equals(self):
alist = [random.randint(1,10) for i in range(1000)]
b1 = Bag(alist)
random.shuffle(alist)
b2 = Bag(alist)
self.assertEqual(b1,b2)
b1.remove(alist[0])
self.assertNotEquals(b1,b2)
def test_this_and_that(fake_dict):
assert (2 == len(fake_dict.keys()))
key = Bag("cat")
cat_hits = sorted(fake_dict[key])
assert (cat_hits == ["cat", "tac"])
assert (1 == len(fake_dict[Bag("fred")]))
assert (list(fake_dict[Bag("fred")])[0] == "fred")
def testadd(self):
l = [random.randint(1, 10) for i in range(1000)]
first = Bag(l)
second = Bag([])
random.shuffle(l)
for i in l:
second.add(i)
assert first == second
def test_this_and_that(self):
self.assert_(2 == len(self.fake_dict.keys()))
cat_hits = self.fake_dict[Bag("cat")]
self.assert_(2 == len(cat_hits))
self.assert_(cat_hits[0] == "cat")
self.assert_(cat_hits[1] == "tac")
self.assert_(1 == len(self.fake_dict[Bag("fred")]))
self.assert_(self.fake_dict[Bag("fred")][0] == "fred")
def test_add(self):
temp_list = [random.randint(1,10) for i in range(1,1001)]
b1 = Bag(temp_list)
b2 = Bag()
random.shuffle(temp_list)
for i in temp_list:
b2.add(i)
self.assertEqual(b1,b2)
def test_eq(self):
temp_list = [random.randint(1,10) for i in range(1,1001)]
b1 = Bag(temp_list)
random.shuffle(temp_list)
b2 = Bag(temp_list)
self.assertEqual(b1,b2)
b2.remove(temp_list[0])
self.assertNotEqual(b1,b2)
def test_equals(self):
vals = [random.randint(1, 10) for i in range(1000)]
bag1 = Bag(vals)
random.shuffle(vals)
bag2 = Bag(vals)
self.assertTrue(bag1 == bag2, 'bags are not equal')
bag1.remove(vals[0])
self.assertFalse(bag1 == bag2, 'bags are not supposed to be equal')
def test_add(self):
to_bag = [random.randrange(1, 11) for i in range(1000)]
bag1 = Bag(to_bag)
random.shuffle(to_bag)
bag2 = Bag()
for i in to_bag:
bag2.add(i)
self.assertEqual(bag1, bag2, "Bags are not equal.")
def __init__(self):
self.bag = Bag()
self.bag.createTiles()
self.bag.shuffleTiles()
self.board = Board()
self.player_list = []
self.strategy_to_player = {}
for strategy_num in range(1, 3):
self.player_list.append(Player(strategy_num))
def testEqual(self):
test_list = [random.randint(1,10) for i in range(1000)]
test_bag1 = Bag(test_list)
random.shuffle(test_list)
test_bag2 = Bag(test_list)
self.assertTrue(test_bag1==test_bag2)
test_bag2.remove(test_list[0])
self.assertFalse(test_bag1==test_bag2)
def test_add(self):
rand_list = [random.randint(1, 10)
for i in range(0, 1000)] #Make 1000-value random list
bag1 = Bag(rand_list) #Create bag from random list
bag2 = Bag() #Create another bag from shuffled random list
random.shuffle(rand_list) #Shuffle random list
for x in rand_list:
bag2.add(x)
self.assertEqual(bag1, bag2)
def test_equal(self):
print('Checking for equal')
alist = [random.randint(1,10) for i in range(1000)]
bag1 = Bag(alist)
random.shuffle(alist)
bag2 = Bag(alist)
self.assertEqual(bag1, bag2, 'Two back must be equal initially')
bag2.remove(alist[0])
self.assertNotEqual(bag1, bag2, 'Two back must not be equal after removing the first element of bag2')
def __init__(self, *args):
self.players = []
for count, arg in enumerate(*args, start=1):
if not arg:
self.players.append(HumanPlayer(f'Player {count}'))
else:
self.players.append(Player(f'Computer {count}'))
self.game_bag = Bag()
self.round = 1
def test_add(self):
bag2 = []
for i in range(0,1000):
bag2.append((random.randint(1,10)))
check_bag = Bag(bag2)
check_bag2 = Bag()
random.shuffle(bag2)
for i in check_bag:
check_bag2.add(i)
self.assertEqual(check_bag,check_bag2)
def testadd(self):
rand_list = []
for i in range(1000):
rand_list.append(random.randint(1, 10))
bag = Bag(rand_list)
bag2 = Bag()
random.shuffle(rand_list)
for value in rand_list:
bag2.add(value)
assert bag == bag2
def testequals(self):
rand_list = []
for i in range(1000):
rand_list.append(random.randint(1, 10))
bag = Bag(rand_list)
random.shuffle(rand_list)
bag2 = Bag(rand_list)
assert bag == bag2
bag.remove(rand_list[0])
assert bag != bag2
def __init__(self, name: str, *pokemons: tuple, level: int = 5):
self.name = name.capitalize()
self.bag = Bag()
self.party = Party(
*(Pokemon(pokemon,
level=randint(floor(level * 0.9), floor(level * 1.1)))
for pokemon in pokemons) if pokemons else Pokemon(choice(
['bulbasaur', 'charmander', 'squirtle', 'pikachu']),
level=5))
self.in_battle = False
def __init__(self, PID_players=[], PID_my=[]):
self.lock = threading.RLock()
self.board = Board() # Master Board
self.scores = [] # List of all players' scores
self.bag = Bag() # Bag of remaining tiles
# Used to check if first move overlaps with center tile
self.first_move = True
# List of PID of players so board can use imported send_message
self.PID_players = PID_players
self.PID_my = PID_my # Current PID
def test_eq(self):
bag2 = []
for i in range(0,1000):
bag2.append((random.randint(1,10)))
check_bag = Bag(bag2)
random.shuffle(bag2)
check_bag2 = Bag(bag2)
self.assertEqual(check_bag,check_bag2)
check_bag.remove(bag2[0])
self.assertNotEqual(check_bag,check_bag2)
def decode_rule(rule):
idx = rule.index(BAGS_CONTAINED)
color = rule[0:idx].strip()
b = Bag(color)
if rule.endswith('no other bags.') == False:
contains = rule[idx + len(BAGS_CONTAINED):].strip().split(',')
for contain in contains:
c, n = decode_sub_colors(contain.strip())
b.add_contained_bag(c, n)
return b
def __init__(self, root):
self.__root = root
self.__board = Board(root)
self.__bag = Bag()
self.__human = Human(root)
self.__ai = Ai(root, self.__board, self.__bag)
self.__turn = 1
self.__player = self.__human
self.__human_score = StringVar()
self.__ai_score = StringVar()
def evaluate_pathway(list_of_paths):
scores = []
# create a set of all participating enzymes, and count the number of enzymes that are not trivial
total_path_length = 0
enzyme_bag = Bag()
enzyme_type_bag = Bag()
for path in list_of_paths:
for enzyme in path_to_enzyme_list(path):
if (not enzyme in pp_enzymes):
total_path_length += 1
enzyme_bag[enzyme] += 1
enzyme_type_bag[enzyme_types[enzyme]] += 1
scores.append((params['TL'], total_path_length))
scores.append((params['NE'], enzyme_type_bag['EPI']))
scores.append((params['NI'], enzyme_type_bag['ISO']))
scores.append((params['NK'], enzyme_type_bag['KIN']))
scores.append((params['ND'], enzyme_type_bag['DHG']))
num_isoenzymes = 0
for (enzyme, count) in enzyme_bag.itercounts():
if (count > 1):
num_isoenzymes += 1
scores.append((params['MIE'], num_isoenzymes))
total_phosphorilation_distance = 0
for path in list_of_paths:
for enzyme in path_to_enzyme_list(path):
if (enzyme_types[enzyme] == "KIN"):
break
else:
total_phosphorilation_distance += 1
scores.append((params['TPD'], total_phosphorilation_distance))
# NTE - Number maximum number of same-product epimerases
G = pathway_to_graph(list_of_paths)
max_epimerase_count = 0
max_split = 0
for v in G.itervertices():
epimerase_count = 0
for child in G[v]:
if (enzyme_types[(v, child)] == "EPI"):
epimerase_count += 1
max_epimerase_count = max(max_epimerase_count, epimerase_count)
max_split = max(max_split, len(G[v]))
scores.append((params['NTE'], max_epimerase_count))
# copy on the scores that have a parameter which is not None.
chosen_scores = []
for (p, s) in scores:
if (p != None):
chosen_scores.append((p, s))
chosen_scores.sort()
return tuple([s[1] for s in chosen_scores])
def test_equals(self):
listone = []
listtwo = []
for x in range(1000):
c = random.randint(1, 10)
listone.append(c)
listtwo.append(c)
random.shuffle(listone)
b1 = Bag(listone)
b2 = Bag(listtwo)
self.assertTrue(b1 == b2)
def test_add(self):
alist = []
for i in range(1000):
alist.append(random.randint(1, 10))
b1 = Bag(alist)
random.shuffle(alist)
b2 = Bag()
for a in alist:
b2.add(a)
if b1 != b2:
raise
def test_remove(self):
temp_list = []
for i in range(1,1001):
temp_list.append(random.randint(1,10))
b1 = Bag(temp_list)
self.assertRaises(ValueError,self.bag.remove,33)
b2 = Bag(temp_list)
for i in temp_list:
b2.add(i)
b2.remove(i)
self.assertEqual(b1,b2)
def test_remove(self):
alist = [random.randint(1,10) for i in range(1000)]
b1 = Bag(alist)
self.assertRaises(ValueError,b1.remove,11)
b2 = Bag(alist)
random.shuffle(alist)
for v in alist:
b2.add(v)
for v in alist:
b2.remove(v)
self.assertEqual(b1,b2)
def evaluate_pathway(list_of_paths):
scores = []
# create a set of all participating enzymes, and count the number of enzymes that are not trivial
total_path_length = 0
enzyme_bag = Bag()
enzyme_type_bag = Bag()
for path in list_of_paths:
for enzyme in path_to_enzyme_list(path):
if (not enzyme in pp_enzymes):
total_path_length += 1
enzyme_bag[enzyme] += 1
enzyme_type_bag[enzyme_types[enzyme]] += 1
scores.append((params['TL'], total_path_length))
scores.append((params['NE'], enzyme_type_bag['EPI']))
scores.append((params['NI'], enzyme_type_bag['ISO']))
scores.append((params['NK'], enzyme_type_bag['KIN']))
scores.append((params['ND'], enzyme_type_bag['DHG']))
num_isoenzymes = 0
for (enzyme, count) in enzyme_bag.itercounts():
if (count > 1):
num_isoenzymes += 1
scores.append((params['MIE'], num_isoenzymes))
total_phosphorilation_distance = 0
for path in list_of_paths:
for enzyme in path_to_enzyme_list(path):
if (enzyme_types[enzyme] == "KIN"):
break
else:
total_phosphorilation_distance += 1
scores.append((params['TPD'], total_phosphorilation_distance))
# NTE - Number maximum number of same-product epimerases
G = pathway_to_graph(list_of_paths)
max_epimerase_count = 0
max_split = 0
for v in G.itervertices():
epimerase_count = 0
for child in G[v]:
if (enzyme_types[(v, child)] == "EPI"):
epimerase_count += 1
max_epimerase_count = max(max_epimerase_count, epimerase_count)
max_split = max(max_split, len(G[v]))
scores.append((params['NTE'], max_epimerase_count))
# copy on the scores that have a parameter which is not None.
chosen_scores = []
for (p, s) in scores:
if (p != None):
chosen_scores.append((p, s))
chosen_scores.sort()
return tuple([s[1] for s in chosen_scores])
def __init__(self, *args):
self.board = Board()
self.bag = Bag()
self.nextPiece = None
self.onBoard = False
self.highlight = 0
self.isPlayerOne = True
def test_remove():
bag = Bag()
bag.add(1, 10)
bag.add(2, 20)
bag.add(1, 10)
bag.add(1, 20)
pairs = bag.find_all(1)
assert bag.remove(1) in pairs
assert len(bag.find_all(1)) == len(pairs) - 1
assert bag.remove(2) == (2, 20)
assert bag.remove(2) == None
def edges(self):
l = Bag()
for v in range(self._v):
self_loops = 0
for edge in self.adjacent(v):
if edge.other(v) > v:
l.add(edge)
elif edge.other(v) == v:
if self_loops % 2 == 0:
l.add(edge)
self_loops += 1
return l
def test_remove(self):
to_bag = [random.randrange(1, 11) for i in range(1000)]
bag1 = Bag(to_bag)
self.assertRaises(ValueError, Bag.remove, bag1, 32)
bag2 = Bag(to_bag)
for i in to_bag:
bag2.add(i)
for i in to_bag:
bag2.remove(i)
self.assertEqual(bag1, bag2, "Bags are not equal.")
def testAdd(self):
test_list = [random.randint(1,10) for i in range(1000)]
test_bag1 = Bag(test_list)
test_bag2 = Bag()
random.shuffle(test_list)
for i in test_list:
test_bag2.add(i)
self.assertTrue(test_bag1==test_bag2)
def test_remove(self):
print('Checking for remove')
alist = [random.randint(1,10) for i in range(1000)]
bag1 = Bag(alist)
self.assertRaises(ValueError, Bag.remove,bag1,32)
bag2 = Bag(alist)
for el in alist:
bag2.add(el)
for el in alist:
bag2.remove(el)
self.assertEqual(bag1,bag2, 'Two bag must be same after removing elements from bag2')
def testRemove(self):
test_list = [random.randint(1,10) for i in range(1000)]
test_bag1 = Bag(test_list)
self.assertRaises(ValueError,test_bag1.remove, 21)
test_bag2 = Bag(test_list)
for i in test_list:
test_bag2.add(i)
for i in test_list:
test_bag2.remove(i)
self.assertEqual(test_bag1,test_bag2)
def randomized_select(self, select_range, priority_fn, lowestPriority=False):
solution = list()
total_profit = 0
bag = Bag(self.P, self.M, self.constraints)
options = list()
for item in self.items:
options.append((item, priority_fn(item)))
options.sort(key=lambda x: -x[1])
if lowestPriority:
options = list(reversed(options))
options = [x[0] for x in options]
while len(options) > 0 and not bag.full():
items = options[:min(select_range, len(options))]
item = items[int(random() * len(items))]
options.remove(item)
print(" progress: {0:.2f} %".format(max(bag._weight / bag.P, bag._cost/bag.M) * 100), end="\r")
if bag.has_enough_weight_for(item.weight) and bag.has_enough_money_for(item.cost):
bag.take(item)
solution.append(item)
total_profit += item.profit
new_options = list()
for x in options:
if bag.can_take(x.classNumber):
new_options.append(x)
options = new_options
return (total_profit, solution)
def test_remove(self):
bag2 = []
for i in range(0,1000):
bag2.append((random.randint(1,10)))
check_bag = Bag(bag2)
self.assertRaises(ValueError, check_bag.remove,21)
check_bag2 = Bag(bag2)
for i in bag2:
check_bag2.add(i)
for i in bag2:
check_bag2.remove(i)
self.assertEqual(check_bag,check_bag2)
def bag_op(inbag_filenames, allow_unindexed, copy_fn, op, output_dir=None, force=False, quiet=False):
for inbag_filename in inbag_filenames:
# Check we can read the file
try:
inbag = Bag(inbag_filename, 'r', allow_unindexed=allow_unindexed)
except ROSBagUnindexedException:
print >> sys.stderr, 'ERROR bag unindexed: %s. Run rosbag reindex.' % inbag_filename
continue
except (ROSBagException, IOError), ex:
print >> sys.stderr, 'ERROR reading %s: %s' % (inbag_filename, str(ex))
continue
# Determine whether we should copy the bag
copy = copy_fn(inbag)
inbag.close()
# Determine filename for output bag
if output_dir is None:
outbag_filename = inbag_filename
else:
outbag_filename = os.path.join(output_dir, os.path.split(inbag_filename)[1])
backup_filename = None
if outbag_filename == inbag_filename:
# Rename the input bag to ###.orig.###, and open for reading
backup_filename = '%s.orig%s' % os.path.splitext(inbag_filename)
if not force and os.path.exists(backup_filename):
if not quiet:
print >> sys.stderr, 'Skipping %s. Backup path %s already exists.' % (inbag_filename, backup_filename)
continue
try:
if copy:
shutil.copy(inbag_filename, backup_filename)
else:
os.rename(inbag_filename, backup_filename)
except OSError, ex:
print >> sys.stderr, 'ERROR %s %s to %s: %s' % ('copying' if copy else 'moving', inbag_filename, backup_filename, str(ex))
continue
source_filename = backup_filename
def __init__(self, players, computers, dictionary='sowpods.txt'):
"""Sets up initial game state with player names given"""
self.bag = Bag()
self.board = Board()
self.player_order = players + sorted(computers.keys())
self.computers = computers
self.players = {}
for player in players:
self.players[player] = Player(player,self)
for computer in computers:
self.players[computer] = AI(computer, self, computers[computer])
self.turn = 0
self.played = False
self.dictionary = Dictionary(dictionary)
def greedy_on_fn(self, priority_fn, lowestPriority=False):
solution = list()
total_profit = 0
bag = Bag(self.P, self.M, self.constraints)
queue = get_priority_queue(self.items, priority_fn, lowestPriority)
while not queue.isEmpty() and not bag.full():
item = queue.pop()
#print(" remaining items: {0:.2f}%".format(queue.count / self.N * 100), end="\r")
print(" progress: {0:.2f} %".format(max(bag._weight / bag.P, bag._cost/bag.M) * 100), end="\r")
if bag.has_enough_weight_for(item.weight) and bag.has_enough_money_for(item.cost):
if bag.can_take(item.classNumber):
solution.append(item)
bag.take(item)
total_profit += item.profit
return (total_profit, solution)
def edges(self):
l = Bag()
for v in range(self._v):
for edge in self.adjacent(v):
l.add(edge)
return l
from item import Item from bag import Bag def makeBag(pattern, dic): aux = [] for x in range(0 , len(pattern)): if pattern[x] == 1: aux.append(dic[x]) return Bag(aux) items = [Item(150,20,1), Item(325,40,2), Item(600,50,3), Item(805,36,4), Item(430,25,5), Item(1200,64,6), Item(770,54,7), Item(60,18,8), Item(930,46,9), Item(353,28,10)] bb = Bag() for a in range(0, 2): for b in range(0, 2): for c in range(0, 2): for d in range(0, 2): for e in range(0, 2): for f in range(0, 2): for g in range(0, 2): for h in range(0, 2): for i in range(0, 2): for j in range(0, 2): pattern = [a,b,c,d,e,f,g,h,i,j] bag = makeBag(pattern, items) if bag.getSize() <= 4200: if bag.getTotalValue() >= bb.getTotalValue(): bb = bag
def run_algorithm(self, num_solution_before_stop=100000, time_out=1000000):
"""
This is where we implement our logic and algorithms
Useful Parameters:
self.P -- max weight we can carry
self.M -- max purchasing power in dollars
self.N -- total number of avaliable items
self.C -- total number of constraints
self.items -- all items avaliable for choice
self.constraints -- a Constraint class with constraints
"""
# STEP: Create a hashmap from class number to its items
item_map = dict()
for item in self.items:
if item.classNumber not in item_map:
item_map[item.classNumber] = set()
item_map[item.classNumber].add(item)
# STEP: Calculate the total weight, cost, value, and profit of each class
def get_class_stats(items):
total_weight = 0
total_cost = 0
total_value = 0
total_profit = 0
for item in items:
total_weight += item.weight
total_cost += item.cost
total_value += item.value
total_profit += item.profit
return (total_weight, total_cost, total_value, total_profit)
class_stats = dict() # Format: key: class -> value: (weight, cost, value, profit)
for classNumber in item_map.keys():
class_stats[classNumber] = get_class_stats(item_map[classNumber])
# STEP: Create a BAG instance
bag = Bag(self.P, self.M, self.constraints)
# STEP: PriorityQueues of class's values
fn_extract_profit_per_weight_ratio = lambda x: x.profit_per_weight_ratio()
def fn_extractclass_ratio(x):
weight, _, _, profit = class_stats[x]
if weight == 0:
ratio = float("inf")
else:
ratio = profit / weight
return ratio
class_queue = PriorityQueue(lowest_priority=False) # based on class's item profit_per_weight_ratio
for classNumber in item_map.keys():
class_queue.push(classNumber, fn_extractclass_ratio(classNumber))
def add_to_queue(items, fn_extract_priority, queue):
for item in items:
priority_value = fn_extract_priority(item)
queue.push(item, -priority_value)
return queue
def get_queue_of_items(items, fn_extract_priority):
queue = PriorityQueue(lowest_priority=False)
return add_to_queue(items, fn_extract_priority, queue)
# STEP: pick from the bag with highest ratio
solutions_found = dict()
num_solution_found = 0
iteration = 0
class_not_used_due_to_conflict = Queue()
add_back_conflicts = True
while num_solution_found <= num_solution_before_stop and iteration <= time_out:
while not class_queue.isEmpty() and iteration <= time_out:
iteration += 1
if iteration % (time_out / 1000) == 0:
print("iteration {0} -- rate: {1:.2f} %".format(iteration, iteration / time_out * 100), end="\r")
if not class_not_used_due_to_conflict.isEmpty():
class_to_use = class_not_used_due_to_conflict.pop()
add_back_conflicts = not add_back_conflicts
else:
class_to_use = class_queue.pop()
add_back_conflicts = not add_back_conflicts
if bag.can_take(class_to_use):
items_queue = get_queue_of_items(item_map[class_to_use], \
fn_extract_profit_per_weight_ratio)
item = items_queue.pop()
while bag.take(item):
if not items_queue.isEmpty():
item = items_queue.pop()
else:
break
num_solution_found += 1
solutions_found[bag.score()] = bag.items()
print("solution {0} found".format(num_solution_found))
else:
class_not_used_due_to_conflict.push(class_to_use)
if num_solution_found >= num_solution_before_stop:
break
# print("iteration {0}".format(iteration))
iteration += 1
if add_back_conflicts:
add_to_queue(class_not_used_due_to_conflict.list, fn_extractclass_ratio, class_queue)
if num_solution_found >= num_solution_before_stop:
break
# STEP: return the best combination found
bestSolution = []
bestProfit = 0
for profit, soln in solutions_found.items():
if profit > bestProfit:
bestProfit = profit
bestSolution = soln
return bestSolution
else:
os.rename(inbag_filename, backup_filename)
except OSError, ex:
print >> sys.stderr, 'ERROR %s %s to %s: %s' % ('copying' if copy else 'moving', inbag_filename, backup_filename, str(ex))
continue
source_filename = backup_filename
else:
if copy:
shutil.copy(inbag_filename, outbag_filename)
source_filename = outbag_filename
else:
source_filename = inbag_filename
try:
inbag = Bag(source_filename, 'r', allow_unindexed=allow_unindexed)
# Open the output bag file for writing
try:
if copy:
outbag = Bag(outbag_filename, 'a', allow_unindexed=allow_unindexed)
else:
outbag = Bag(outbag_filename, 'w')
except (ROSBagException, IOError), ex:
print >> sys.stderr, 'ERROR writing to %s: %s' % (outbag_filename, str(ex))
inbag.close()
continue
# Perform the operation
try:
op(inbag, outbag, quiet=quiet)
action="store",
type="string",
dest="dict_fn",
default=dict.default_dict_name,
metavar="FILE",
help="location of word list")
(options, args) = parser.parse_args()
if 0 == len(args):
parser.print_help()
sys.exit(0)
dict_hash_table = dict.snarf_dictionary(options.dict_fn)
the_phrase = Bag(args[0])
print("Pruning dictionary. Before: {} bags ...".format(len(dict_hash_table.keys())),
file=sys.stderr, end='')
# Now convert the hash table to a list, longest entries first. (This
# isn't necessary, but it makes the more interesting anagrams appear
# first.)
# While we're at it, prune the list, too. That _is_ necessary for the
# program to finish before you grow old and die.
the_dict_list = [[k, dict_hash_table[k]]
for k in dict_hash_table.keys()
if the_phrase.subtract(k)]
# Note that sorting entries "alphabetically" only makes partial sense,
