View difference between Paste ID: eQQLdi0a and 51N98yzu

 # Trying to simulate a simple economy, based on Doran & Parberry (2010)
 
 from __future__ import division
 import random
 import cProfile
 import pstats
 
 break_chances = {'tools':5, 'wood':10}
 
 HIST_WINDOW_SIZE = 10 # Amount of trades auctions keep in memory to determine avg price (used by agents)
 MAX_INVENTORY_SIZE = 15 # A not-really-enforced max inventory limit
 
 PROFIT_MARGIN = 1.5 # Won't sell an item for lower than this * normalized production cost
 STARTING_GOLD = 1000 # How much gold each agent starts with
 TAXES = 2 # How much gold is payed in taxes per turn
 
 MIN_CERTAINTY_VALUE = 8 ## Within what range traders are limited to estimating the market price
 BID_REJECTED_ADJUSTMENT = 5 # Adjust prices by this much when our bid is rejected
 ASK_REJECTED_ADJUSTMENT = 5 # Adjust prices by this much when nobody buys our stuff
 REJECTED_UNCERTAINTY_AMOUNT = 2 # We get this much more uncertain about a price when an offer is rejected
 ACCEPTED_CERTAINTY_AMOUNT = 1  # Out uncertainty about a price decreases by this amount when an offer is accepted
 
 P_DIF_ADJ = 3  # When offer is accepted and exceeds what we thought the price value was, adjust it upward by this amount
 N_DIF_ADJ = 3  # When offer is accepted and is lower than what we thought the price value was, adjust it downward by this amount
 P_DIF_THRESH = 2  #Threshhold at which adjustment of P_DIF_ADJ is added to the perceived value of a commodity
 N_DIF_THRESH = 1.6 #Threshhold at which adjustment of P_DIF_ADJ is subtracted from the perceived value of a commodity
 
 START_VAL = 50 # Arbitrary value that sets the starting price of good (in gold)
 START_UNCERT = 10 # Arbitrary uncertainty value (agent believes price is somewhere between (mean-this, mean+this)
 
 def roll(a, b):
 	return random.randint(a, b)
 
 class Value:
 	# Agents' perceived values of objects
 	def __init__(self, center, uncertainty):
 		self.center = center
 		self.uncertainty = uncertainty
 
 class Auction:
 	# Seperate "auction" for each commodity
 	# Runs each round of bidding, as well as archives historical price info
 	def __init__(self, commodity):
 		self.commodity = commodity
 		self.bids = []
 		self.asks = []
 		self.price_history = []
 		self.mean_price = START_VAL
 
 	def update_mean_price(self):
 		# update the mean price for this commodity by averaging over the last HIST_WINDOW_SIZE items
 		self.mean_price = int(round(sum(self.price_history[-HIST_WINDOW_SIZE:])/len(self.price_history[-HIST_WINDOW_SIZE:])))
 
 class Offer:
 	# An offer that goes into the auction's "bids" or "asks".
 	# Bids and asks are then compared against each other and agents meet at the middle
 	def __init__(self, owner, commodity, price, quantity):
 		self.owner = owner
 		self.commodity = commodity
 		self.price = price
 		self.quantity = quantity
 
 
 class Agent:
 	# An agent in the economy. They produce items, make bids and sell requests, and pay taxes
 	def __init__(self, name, output, required_items, used_items, consumed_items):
 		global num_agents
 		# Add self to list of agents
 		agents.append(self)
 
 		self.name = name
 		self.output = output #The product this agent produces (dict of items:amounts)
 		self.required_items = required_items #Things you need, but don't use up in item creation (dict of items:amounts)
 		self.used_items = used_items #Things you transform into the product (dict of items:amounts)
 		self.consumed_items = consumed_items #Things you consume once per turn (food, etc)
 
 		self.inventory_size = MAX_INVENTORY_SIZE
 		self.gold = STARTING_GOLD
 
 		## Create a dict of all things we use. We won't sell anything below the price to produce it, hopefully
 		self.inventory = []
 		self.perceived_values = {} ## dict of what we believe the true price of an item is
 
 		for item, amount in self.required_items.iteritems():
 			self.perceived_values[item] = Value(START_VAL, START_UNCERT)
 			for num in range(amount):
 				self.inventory.append(item)
 
 		for item, amount in self.consumed_items.iteritems():
 			self.perceived_values[item] = Value(START_VAL, START_UNCERT)
 			for num in range(amount):
 				self.inventory.append(item)
 
 		for item, amount in self.used_items.iteritems():
 			self.perceived_values[item] = Value(START_VAL, START_UNCERT)
 			for num in range(amount):
 				self.inventory.append(item)
 
 		## Start off with 2x the stuff that you produce so you can begin selling right away
 		self.num_produced_items = 0
 		for item, amount in self.output.iteritems():
 			self.perceived_values[item] = Value(START_VAL, START_UNCERT)
 
 			self.num_produced_items += amount
 			for num in range(amount*2):
 				self.inventory.append(item)
 
 	def produce_items(self):
 		# Verbose way to test if we have the correct items
 		can_produce = True
 		for item, amount in self.required_items.iteritems():
 			if self.inventory.count(item) < amount:
 				can_produce = False
 				break
 		if len(self.used_items) > 0:
 			for item, amount in self.used_items.iteritems():
 				if self.inventory.count(item) < amount:
 					can_produce = False
 					break
 		# For items like food that are consumed on the side
 		if len(self.consumed_items) > 0:
 			for item, amount in self.consumed_items.iteritems():
 				if self.inventory.count(item) < amount:
 					can_produce = False
 					break
 
 		## If we can produce stuff, then actually do it
 		if can_produce:
 			# Remove the used_items in the inv.
 			for item, amount in self.used_items.iteritems():
 				for x in xrange(amount):
 					self.inventory.remove(item)
 			# Produce stuff
 			for item, amount in self.output.iteritems():
 				for x in xrange(amount):
 					self.inventory.append(item)
 			# Stuff can break:
 			for item, amount in self.required_items.iteritems():
 				for x in xrange(amount):
 					if roll(1, break_chances[item]) == 1:
 						self.inventory.remove(item)
 			# Consume stuff
 			for item, amount in self.consumed_items.iteritems():
 				for x in xrange(amount):
 					self.inventory.remove(item)
 
 
 	def has_space(self, amount):
 		return (self.inventory_size - len(self.inventory)) > amount
 
 	def determine_purchase_quantity(self, commodity):
 		# First find historical mean price and our observed mean prices
 		historical_mean = auctions[commodity].mean_price
 		our_belief = self.perceived_values[commodity].center
 		# Pseudocode from Doran & Parberry (2010):
 		#favorability = max price - position of mean within observed trading range
 
 		# I guess this should be a float, >1 means good, <1 means bad. Will adjust requested amt accordingly
 		favorability = our_belief/historical_mean
 
 		#Force them to bid at least 1, for now
 		available_space = self.inventory_size - len(self.inventory)
 		return max(int(round(favorability * available_space)), 1)
 
 
 	def determine_sale_quantity(self, commodity):
 		# First find historical mean price and our observed mean prices
 		historical_mean = auctions[commodity].mean_price
 		our_belief = self.perceived_values[commodity].center
 
 		# Pseudocode from Doran & Parberry (2010):
 		#favorability = max price - position of mean within observed trading range
 
 		# I guess this should be a float, >1 means good, <1 means bad. Will adjust requested amt accordingly
 		favorability = historical_mean/our_belief
 		#Force them to sell at least 1, for now
 		return max(int(round(favorability * (self.inventory.count(commodity)))), 1)
 
 
 	def has(self, commodity, amount=1):
 		return self.inventory.count(commodity) >= amount
 
 	def eval_need(self):
 		# See if we need items to continue producing our goods
 		for item, amount in self.used_items.iteritems():
 			if not self.has(item, amount):
 				self.create_bid(self, item, amount)
 
 		for item, amount in self.required_items.iteritems():
 			if not self.has(item, amount):
 				self.create_bid(self, item, amount)
 
 		for item, amount in self.consumed_items.iteritems():
 			if not self.has(item, amount):
 				self.create_bid(self, item, amount)
 
 
 	def eval_sell(self):
 		# If we have stuff we've made, offer to sell it
 		for item, amount in self.output.iteritems():
 			if self.inventory.count(item) > 0:
 				self.create_ask(self, item, self.inventory.count(item))
 
 	def create_bid(self, agent, commodity, limit):
 		# If we decide to bid, here's how we do it
 		est_price = self.perceived_values[commodity].center
 		uncertainty = self.perceived_values[commodity].uncertainty
 		bid_price = roll(est_price - uncertainty, est_price + uncertainty)
 		if bid_price > self.gold:
 			bid_price = self.gold
 
 		# Find ideal amount - should we pass bid price to this and compare that to hist. mean?
 		ideal_quantity = self.determine_sale_quantity(commodity)
 		# Determine quantity
 		quantity_to_buy = min(ideal_quantity, limit)
 
 		if quantity_to_buy > 0:
 			auctions[commodity].bids.append(Offer(owner=agent, commodity=commodity, price=bid_price, quantity=quantity_to_buy))
 
 
 	def check_production_cost(self):
 		### Might change this to reflect agent's own beliefs about price, rather than historical avgs ###
 		production_cost = 0
 
 		# Cost of used_items is historical mean * the amount we use (since they are used up every
 		# time we need to make something, we're using the full value of the items)
 		for item, amount in self.used_items.iteritems():
 			production_cost += (auctions[item].mean_price * amount)
 
 		# These items are required for production, but not used. Each one has a break chance, so
 		# the cost of buying one divided by the break chance is the avg cost to buy
 		for item, amount in self.required_items.iteritems():
 			production_cost += int(round(((auctions[item].mean_price * amount)/break_chances[item])))
 
 		# These items are also used each time we make something, so the full cost of the items are used
 		for item, amount in self.consumed_items.iteritems():
 			production_cost += auctions[item].mean_price * amount
 
 		# Take into account the taxes we pay
 		production_cost += TAXES
 
 		return production_cost
 
 	def create_ask(self, agent, commodity, limit):
 		# Determines how many items to sell, and at what cost
 		production_cost = self.check_production_cost()
 		min_sale_price = int(round((production_cost/self.num_produced_items)*PROFIT_MARGIN))
 
 		est_price = self.perceived_values[commodity].center
 		uncertainty = self.perceived_values[commodity].uncertainty
 		# won't go below what they paid for it
 		ask_price = max(roll(est_price - uncertainty, est_price + uncertainty), min_sale_price)
 
 		ideal_quantity = self.determine_purchase_quantity(commodity)
 		# Paper says should be max(ideal, limit), but that creates an offer bigger than what we have in inventory?
 		quantity_to_sell = min(ideal_quantity, limit)
 
 		if quantity_to_sell > 0:
 			auctions[commodity].asks.append(Offer(owner=agent, commodity=commodity, price=ask_price, quantity=quantity_to_sell))
 
 
 	def eval_trade_accepted(self, commodity, price):
 		# Then, adjust our belief in the price
 		if self.perceived_values[commodity].uncertainty >= MIN_CERTAINTY_VALUE:
 			self.perceived_values[commodity].uncertainty -= ACCEPTED_CERTAINTY_AMOUNT
 
 		our_mean = (self.perceived_values[commodity].center)
 
 		if price > our_mean * P_DIF_THRESH:
 			self.perceived_values[commodity].center += P_DIF_ADJ
 		elif price < our_mean * N_DIF_THRESH:
 			# We never let it's worth drop under a certain % of tax money.
 			self.perceived_values[commodity].center = max(self.perceived_values[commodity].center - N_DIF_ADJ, TAXES*5 + self.perceived_values[commodity].uncertainty)
 
 
 	def eval_ask_rejected(self, commodity, price):
 		# What to do when we put something up for sale and nobody bought it
 		self.perceived_values[commodity].center -= ASK_REJECTED_ADJUSTMENT
 		self.perceived_values[commodity].uncertainty += REJECTED_UNCERTAINTY_AMOUNT
 
 	def eval_bid_rejected(self, commodity, price):
 		# What to do when we've bid on something and didn't get it
 		self.perceived_values[commodity].center += BID_REJECTED_ADJUSTMENT
 		self.perceived_values[commodity].uncertainty += REJECTED_UNCERTAINTY_AMOUNT
 
 
 def add_new_agent():
 	# Create a new agent
 	num = roll(1, 5)
 
 	if num == 1: farmer = Agent(name='farmer', output={'food':4}, required_items={'wood':1, 'tools':1}, used_items={}, consumed_items={})
 	elif num == 2: miner = Agent(name='miner', output={'ore':1}, required_items={'tools':1}, used_items={}, consumed_items={'food':1})
 	elif num == 3: refiner = Agent(name='refiner', output={'metal':1}, required_items={'tools':1}, used_items={'ore':1}, consumed_items={'food':1})
 	elif num == 4: woodcutter = Agent(name='woodcutter', output={'wood':2}, required_items={'tools':1}, used_items={}, consumed_items={'food':1})
 	elif num == 5: blacksmith = Agent(name='blacksmith', output={'tools':2}, required_items={}, used_items={'metal':1, 'wood':1}, consumed_items={'food':1})
 
 
 def create_agents(num_agents):
 	global agents
 	## Create some agents ##
 	agents = []
 	for iteration in range(num_agents):
-		farmer = Agent(name='farmer', output={'food':4}, required_items={'wood':1, 'tools':1}, used_items={},
+		farmer = Agent(name='farmer', output={'food':4}, required_items={'wood':1, 'tools':1}, used_items={}, consumed_items={})
-					consumed_items={})
+		miner = Agent(name='miner', output={'ore':4}, required_items={'tools':1}, used_items={}, consumed_items={'food':1})
-		miner = Agent(name='miner', output={'ore':4}, required_items={'tools':1}, used_items={},
+		refiner = Agent(name='refiner', output={'metal':1}, required_items={'tools':1}, used_items={'ore':1}, consumed_items={'food':1})
-					consumed_items={'food':1})
+		woodcutter = Agent(name='woodcutter', output={'wood':2}, required_items={'tools':1}, used_items={}, consumed_items={'food':1})
-		refiner = Agent(name='refiner', output={'metal':1}, required_items={'tools':1}, used_items={'ore':1},
+		blacksmith = Agent(name='blacksmith', output={'tools':1}, required_items={}, used_items={'metal':1, 'wood':1}, consumed_items={'food':1})
-					consumed_items={'food':1})
+
-		woodcutter = Agent(name='woodcutter', output={'wood':2}, required_items={'tools':1}, used_items={},
+
-					consumed_items={'food':1})
+
-		blacksmith = Agent(name='blacksmith', output={'tools':1}, required_items={}, used_items={'metal':1, 'wood':1},
+
-					consumed_items={'food':1})
+
 		prices = {'wood':[], 'food':[], 'ore':[], 'metal':[], 'tools':[]}
 		# First, each agent does what they do
 		for agent in reversed(agents):
 			agent.produce_items()
 			agent.eval_sell()
 			agent.gold -= TAXES
 			if agent.gold > 0:
 				agent.eval_need()
 			else:
 				agents.remove(agent)
 				#print('Removing a ' + agent.name)
 				add_new_agent()
 
 		## Run the auction
 		for commodity, auction in auctions.iteritems():
 			# Remove any bias? Not sure how much this does, if we're sorting them by price anyway
 			random.shuffle(auction.bids)
 			random.shuffle(auction.asks)
 			## Sort the bids by price (highest to lowest) ##
 			auction.bids = sorted(auction.bids, key=lambda attr: attr.price, reverse=True)
 			## Sort the asks by price (lowest to hghest) ##
 			auction.asks = sorted(auction.asks, key=lambda attr: attr.price)
 
 			num_bids = len(auction.bids)
 			num_asks = len(auction.asks)
 
 			while not len(auction.bids) == 0 and not len(auction.asks) == 0:
 				buyer = auction.bids[0]
 				seller = auction.asks[0]
 				# Determine price/amount
 				quantity = min(buyer.quantity, seller.quantity)
 
 				price = int(round((buyer.price + seller.price)/2))
 
 				if quantity > 0:
 					# Adjust buyer/seller requested amounts
 					buyer.quantity -= quantity
 					seller.quantity -= quantity
 
 					buyer.owner.eval_trade_accepted(buyer.commodity, price)
 					seller.owner.eval_trade_accepted(buyer.commodity, price)
 
 					## Update inventories and gold counts
 					for i in range(quantity):
 						buyer.owner.inventory.append(buyer.commodity)
 						seller.owner.inventory.remove(seller.commodity)
 
 					buyer.owner.gold -= (price*quantity)
 					seller.owner.gold += (price*quantity)
 
 				# Add to running tally of prices this turn
 				prices[commodity].append(price)
 
 				# Now that a transaction has occured, bump out the buyer or seller if either is satasfied
 				if seller.quantity == 0: del auction.asks[0]
 				if buyer.quantity == 0: del auction.bids[0]
 
 			# All bidders re-evaluate prices - currently too simplistic
 			if len(auction.bids) > 0:
 				for buyer in auction.bids:
 					buyer.owner.eval_bid_rejected(buyer.commodity, None)
 					auctions[commodity].bids = []
 
 			# All sellers re-evaluate prices - too simplistic as well
 			elif len(auction.asks) > 0:
 				for seller in auction.asks:
 					seller.owner.eval_bid_rejected(seller.commodity, None)
 					auctions[commodity].asks = []
 
 			## Average prices
 			if len(prices[commodity]) > 0:
 				price_mean = int(round(sum(prices[commodity])/len(prices[commodity])))
 				auction.price_history.append(price_mean)
 				# Track mean price for last N turns
 				auction.update_mean_price()
 				#print (auction.commodity + ': ' + str(auction.mean_price) + '. This round: ' +
 				#str(len(prices[commodity])) + ' ' + commodity + ' averaged at $' + str(price_mean) +
 				#' (' + str(num_bids) + ' bids, ' + str(num_asks) + ' asks)')
 			else:
 				auction.price_history.append(auction.price_history[-1])
 				#print (commodity + ' was not sold this round (' + str(num_bids) + ' bids, ' + str(num_asks) + ' asks)')
 
 
 auctions = {'food':Auction('food'), 'wood':Auction('wood'), 'ore':Auction('ore'), 'metal':Auction('metal'), 'tools':Auction('tools')}
 
 
 create_agents(20)
 #cProfile.run('run_simulation(1)', 'economy')
 run_simulation(200)
 
 for auction in auctions.itervalues():
 	print auction.commodity, auction.price_history
 
 agent_nums = {'farmer':0, 'woodcutter':0, 'miner':0, 'blacksmith':0, 'refiner':0}
 for agent in agents:
 	agent_nums[agent.name] += 1
 	#print(agent.name + ': ' + str(agent.gold))
 
 print str(len(agents)), agent_nums
 
 #p = pstats.Stats('economy')
 #p.sort_stats('cumulative').print_stats(37)
 #p.sort_stats('time').print_stats(10)
 #p.sort_stats('file').print_stats('__init__')