def knapsack01(self, keepUnfilled=False): """ knapsack01 Run knapsack01 on different types to get a collection of optimized item list. For all sack limits, setup the single bag optimized for all types. For each type in sizes, retrieve key Run knapsack01 for key add stats from knapsack to single bag If inner j keepUnfilled and isSingleBagFull False break out of inner j and move to next limit set after add items to sackset. Args: keepUnfilled bool if a group returns a unfilled knapsack, should it be kept? Returns: sackset list of group tuple items, total weight, total value, whether all the knapsack are full list of tuples with items (tuple), totwt (int), totval (number), isFull (bool) """ sackset = [] for i in xrange(len(self.limits)): ids = [] wt = 0 val = 0 isSingleBagFull = True for j in xrange(len(self.sizes.keys())): itemTypeKey = sorted(self.sizes.keys())[j] typeBag = knapsack.knapsack01(self.items[itemTypeKey], self.limits[i][j], self.sizes[itemTypeKey]) ids.extend(typeBag[0]) wt = wt + typeBag[2] val = val + typeBag[1] isSingleBagFull = False if typeBag[3] == False else True if keepUnfilled == False and isSingleBagFull == False: break if keepUnfilled == False and isSingleBagFull == False: pass else: sack = (ids, wt, val, isSingleBagFull) sackset.append(sack) return sackset
def setUp(self): self.result = knapsack.knapsack01(items, 100, 2)
def knapsack01(self, keepUnfilled=False): """ KnapSet knapsack01 Run knapsack01 on different types to get a collection of optimized item list. Given a 2d list of limits, where each row corresponds to a set of limits, run knapsack01 on each limit item. Collect sets (rows) of optimized items with the set total value and weight. The sets' isSingleSetFull property is set to True only if all set items are filled to their capacity as determined by knapsack01. The user has the option of keeping only full set. Args: ----- keepUnfilled : bool if a group returns a unfilled knapsack, should it be kept? Returns: -------- knapset : list of tuples in the form: (items, totwt, totval, isSetFull) items : tuple string tuple ids totwt : int total weight totval : float total value isSetFull : bool is set full """ # Unpack variables itm = self.items lmt = self.limits sz = self.sizes knapset = [] # All lineup limits for i in xrange(len(lmt)): ids = [] totwt = 0 totval = 0 isSingleSetFull = True # All types in size keys for j in xrange(len(sz.keys())): type = sorted(sz.keys())[j] typeKnap = knp.knapsack01(itm[type], lmt[i][j], sz[type]) # Unpack isFilled filled = typeKnap[3] if filled==False and keepUnfilled==False: isSingleKnapFull = False break # Unpack typeKnap items = typeKnap[0] val = typeKnap[1] wt = typeKnap[2] # Add up knapsack items and attributes ids.extend(items) totwt = totwt + wt totval = totval + val if keepUnfilled == False and isSingleSetFull == False: pass else: oneset = (ids, totwt, totval, isSingleSetFull) knapset.append(oneset) if not knapset: print "\n[-] Warning : Returning empty KnapSet Object\n" else: print "\n[+] KnapSet finished creating optimized set...\n" return knapset