Python knapsack01 Examples

Example #1

File: sackset.py Project: cjt5144/Cython-Cpp-Examples

	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

Example #2

File: test.py Project: cjt5144/Cython-Cpp-Examples

	def setUp(self):
	
		self.result = knapsack.knapsack01(items, 100, 2)

Example #3

File: knapset.py Project: cjt5144/Cython-Cpp-Examples

	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