def calculate(self): length = len(self.__players) probabilityOfSuccess = [[0 for x in range(length)] for y in range(length)] for i, playerI in enumerate(self.__players): for j, playerJ in enumerate(self.__players): numerator = 0 denominator = 0 for k, playerK in enumerate(self.__players): if k != i and k != j: arg = self.calculateAllianceProbabilityArg(playerI, playerJ, playerK) if (arg > 0): numerator += arg denominator += abs(arg) if denominator != 0: probabilityOfSuccess[i][j] = (numerator / denominator) else: # is it right? probabilityOfSuccess[i][j] = 0 print ("====Prob of Success =====") tablePrint(probabilityOfSuccess) return probabilityOfSuccess
def makeOffers(self): length = len(self.__players) self.__deltaIJ = [[0 for x in range(length)] for y in range(length)] self.__offersIJ = [[0 for x in range(length)] for y in range(length)] for i, playerI in enumerate(self.__players): # calculate where i get offers from playerI.offers = [] for i, playerI in enumerate(self.__players): # calculate where i get offers from for j, playerJ in enumerate(self.__players): if i != j and playerI.position != playerJ.position: EIi = self.__expectedCalc.get_expected_utility_ij()[j][i] #az i ilyennek látja saját győzelmének hasznosságát EIj = self.__expectedCalc.get_expected_utility_ji()[j][i] #i azt gondolja, hogy ha j győz, akkor ennek j ilyen hasznoságot tulajdonít EJj = self.__expectedCalc.get_expected_utility_ij()[i][j] #az j ilyennek látja saját győzelmének hasznosságát EJi = self.__expectedCalc.get_expected_utility_ji()[i][j] #j azt gondolja, hogy ha i győz, akkor ennek i ilyen hasznoságot tulajdonít # 1.) CONFLICT # Ha mind a két fél azt gondolja, hogy ő az erősebb, akkor confrontáció lesz: if EIi > EIj and EIi > 0 and EJj > EJi and EJj > 0: if playerI.power() >= playerJ.power(): # ha I erősebb, akkor az ő pozíciója változatlan marad playerI.offers.append(Offer(playerJ, Offer.CONFRONTATION, playerI.position, EIi)) self.__offersIJ[i][j] = playerI.position elif playerI.power() < playerJ.power(): # ha I gyengébbnek bizonyul, átveszi J pozícióját playerI.offers.append(Offer(playerJ, Offer.CONFRONTATION, playerJ.position, EIi)) self.__offersIJ[i][j] = playerJ.position # 2.) COMPROMISE+ elif EIi > EIj and EIi > 0 and EJj < EJi and EJj > 0: xHatI = (playerI.position - playerJ.position) * (abs(EIi) / (abs(EIi) + abs(EJj))) playerI.offers.append(Offer(playerJ, Offer.COMPROMISE, playerI.position - xHatI, EIi)) #player I kap kiegyezésre ajánlatot... playerJ.offers.append(Offer(playerJ, Offer.COMPROMISE, playerI.position - xHatI, EIi)) #...ami player j-t, a kompromisszumos ajánlattevőt is köti self.__offersIJ[i][j] = playerI.position - xHatI self.__offersIJ[j][i] = playerI.position - xHatI # 3.) CAPITULATE+ elif EIi > EIj and EIi > 0 and EJj < 0: #player I kapitulációra kényszeríti J-t playerJ.offers.append(Offer(playerI, Offer.CAPITULATION, playerI.position, EIi)) self.__offersIJ[i][j] = playerJ.position # 4.) COMPROMISE- elif EIi < EIj and EIi > 0 and EJj > EJi and EJj > 0: # Ha I azt gondolja, hogy ő az erősebb, J pedig azt, hogy ő a gyengébb: xHatI = (playerI.position - playerJ.position) * (abs(EIi) / (abs(EIi) + abs(EJj))) playerI.offers.append(Offer(playerJ, Offer.COMPROMISE, playerI.position - xHatI, EIi)) #player I kap kiegyezésre ajánlatot... playerJ.offers.append(Offer(playerJ, Offer.COMPROMISE, playerI.position - xHatI, EIi)) #...ami player j-t, a kompromisszumos ajánlattevőt is köti self.__offersIJ[i][j] = playerI.position - xHatI self.__offersIJ[j][i] = playerI.position - xHatI # 7.) CAPITULATE- elif EIi < 0 and EJj > EJi and EJj > 0: #player J kapitulációra kényszeríti I-t playerI.offers.append(Offer(playerJ, Offer.CAPITULATION, playerJ.position, EIi)) self.__offersIJ[i][j] = playerJ.position print("==== Offers for %s ====" % playerI.name) objectListPrint(playerI.offers) print("==== offers ====") # offer mátrix nyomtatási célból tablePrint(self.__offersIJ) for player in self.__players: if len(player.offers) > 0: # Ha a max EU alapján akarjuk kiválasztani az offereket, ezt kell használni #max_util = max([offer.eu for offer in player.offers]) #max_offers = [offer for offer in player.offers if offer.eu == max_util] #offer = min(max_offers, key=lambda x: abs(player.position - x.offered_position)) offer = min(player.offers, key=lambda x: abs(player.position - x.offered_position)) #bestOfferFunc = lambda offer : abs(offer.offered_position - player.position) #bestOffer = min(player.offers, key = bestOfferFunc) player.updatePosition(offer.offered_position)
def makeOffers(self): length = len(self.__players) self.__deltaIJ = [[0 for x in range(length)] for y in range(length)] self.__offersIJ = [[0 for x in range(length)] for y in range(length)] for i, playerI in enumerate(self.__players): # calculate where i get offers from playerI.offers = [] for i, playerI in enumerate(self.__players): # calculate where i get offers from for j, playerJ in enumerate(self.__players): if i != j and playerI.position != playerJ.position: EIi = self.__expectedCalc.get_expected_utility_ij()[j][i] #az i ilyennek látja saját győzelmének hasznosságát EIj = self.__expectedCalc.get_expected_utility_ji()[j][i] #i azt gondolja, hogy ha j győz, akkor ennek j ilyen hasznoságot tulajdonít EJj = self.__expectedCalc.get_expected_utility_ij()[i][j] #az j ilyennek látja saját győzelmének hasznosságát EJi = self.__expectedCalc.get_expected_utility_ji()[i][j] #j azt gondolja, hogy ha i győz, akkor ennek i ilyen hasznoságot tulajdonít #if EIi > EIj and EJj > EJi and EIi > 0 and EIj > 0 and EJj > 0 and EJi > 0: # Ha mind a két fél azt gondolja, hogy ő az erősebb, akkor confrontáció lesz: if EIi > EIj and EJj > EJi and EIi > 0 and EJj > 0: if playerI.power() >= playerJ.power(): # ha I erősebb, akkor az ő pozíciója változatlan marad playerI.offers.append(Offer(playerJ, Offer.CONFRONTATION, playerI.position, EIi)) #playerI.offer = offer, amit player I kap, és amit player J-től kap self.__offersIJ[i][j] = playerI.position elif playerI.power() < playerJ.power(): # ha I gyengébbnek bizonyul, átveszi J pozícióját playerI.offers.append(Offer(playerJ, Offer.CONFRONTATION, playerJ.position, EIi)) self.__offersIJ[i][j] = playerJ.position elif EIi > 0 and EIj < 0 and abs(EIi) > abs(EIj) and abs(EJj) < abs(EJi) and EJj < 0 and EJi > 0 and abs(EJj) < abs(EJi) : #xHat = playerJ.power() * ((playerI.position - playerJ.position)/(playerI.power() + playerJ.power())) #szabi előtti változat #if playerI.position > playerJ.position: xHatI = (playerI.position - playerJ.position) * (abs(EIi) / (abs(EIi) + abs(EJj))) #xHatJ = (playerI.position - playerJ.position) * (abs(EJj) / (abs(EIi) + abs(EJj))) self.__deltaIJ[i][j] = (playerI.position - playerJ.position) * (abs(EIi) / (abs(EIi) + abs(EJj))) # !! probálkozás az xHat matrix létrehozásársa playerI.offers.append(Offer(playerJ, Offer.COMPROMISE, playerI.position - xHatI, EIi)) #player I kap kiegyezésre ajánlatot... playerJ.offers.append(Offer(playerJ, Offer.COMPROMISE, playerI.position - xHatI, EIi)) #...ami player j-t, a kompromisszumos ajánlattevőt is köti self.__offersIJ[i][j] = playerI.position - xHatI self.__offersIJ[j][i] = playerI.position - xHatI elif EIi > 0 and EIj < 0 and abs(EIi) < abs(EIj): #player I kapitulációra kényszeríti J-t playerI.offers.append(Offer(playerJ, Offer.CAPITULATION, playerJ.position, EIi)) self.__offersIJ[i][j] = playerJ.position elif EIi > EIj and EJj < EJi and EIi > 0 and EIj > 0:# and EJj > 0: # Ha I azt gondolja, hogy ő az erősebb, J pedig azt, hogy ő a gyengébb: playerI.offers.append(Offer(playerJ, Offer.CONFRONT, playerJ.position, EIi)) # player J offert kap I-től I pozicióját vegye át self.__offersIJ[i][j] = playerJ.position #elif EIi < EIj and EJj > EJi and EIi > 0 and EIj < 0 and EJj > 0 and EJi > 0: # Ha I azt gondolja, hogy ő az erősebb, J pedig azt, hogy ő a gyengébb: # playerI.offers.append(Offer(playerJ, Offer.CONFRONTATION, playerJ.position, EIi)) # player J offert kap I-től I pozicióját vegye át # self.__offersIJ[i][j] = playerJ.position print("==== Offers for %s ====" % playerI.name) objectListPrint(playerI.offers) #print("==== xHat ====") # !! probálkozás az xHat matrix létrehozásársa #tablePrint(self.__deltaIJ) print("==== offers ====") # offer mátrix nyomtatási célból tablePrint(self.__offersIJ) for player in self.__players: if len(player.offers) > 0: # Ha a max EU alapján akarjuk kiválasztani az offereket, ezt kell használni #max_util = max([offer.eu for offer in player.offers]) #max_offers = [offer for offer in player.offers if offer.eu == max_util] #offer = min(max_offers, key=lambda x: abs(player.position - x.offered_position)) compromiseOffers = [offer for offer in player.offers if offer.offer_type == Offer.COMPROMISE] confrontationOffers = [offer for offer in player.offers if offer.offer_type == Offer.CONFRONT] capOffers = [offer for offer in player.offers if offer.offer_type == Offer.CAPITULATION] if len(compromiseOffers) > 0: minComp = min(compromiseOffers, key=lambda x: abs(player.position - x.offered_position)) player.updatePosition(minComp.offered_position) elif len(confrontationOffers) > 0: minConf = min(confrontationOffers, key=lambda x: abs(player.position - x.offered_position)) player.updatePosition(minConf.offered_position) elif len(capOffers) > 0: minCap = min(capOffers, key=lambda x: abs(player.position - x.offered_position)) player.updatePosition(minCap.offered_position)
def calculateExpectedUtility(self): probSuccCalc = ProbabilityOfSuccessCalculator(self.__players) probabilityOfSuccess = probSuccCalc.calculate() probSQCalc = ProbabilityOfStatusQuoCalculator(self.__players, probabilityOfSuccess) probabilityOfStatusQuo = probSQCalc.calculate() length = len(self.__players) self.__expectedUtilityIJ = [[0 for x in range(length)] for y in range(length)] self.__expectedUtilityJI = [[0 for x in range(length)] for y in range(length)] for i, playerI in enumerate(self.__players): for j, playerJ in enumerate(self.__players): probSucc = probabilityOfSuccess[i][j] # probSQ = probabilityOfStatusQuo[i][j] probSQ = 1 usi = USI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[i] ).calculate() ufi = UFI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[i] ).calculate() ubi = UBI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[i] ).calculate() uwi = UWI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[i] ).calculate() usq = USQ( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[i] ).calculate() T = 1 prevDistance = abs(playerI.previousPosition - playerJ.previousPosition) currentDistance = abs(playerI.position - playerJ.position) if prevDistance >= currentDistance: T = 1 else: T = 0 self.__expectedUtilityIJ[i][j] = ( playerJ.salience * (probSucc * usi + (1 - probSucc) * ufi) + (1 - playerJ.salience) * usi - probSQ * usq - (1 - probSQ) * (T * ubi + (1 - T) * uwi) ) probSucc = probabilityOfSuccess[j][i] # probSQ = probabilityOfStatusQuo[j][i] probSQ = 1 usi = USI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[j] ).calculate() ufi = UFI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[j] ).calculate() ubi = UBI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[j] ).calculate() uwi = UWI( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[j] ).calculate() usq = USQ( self.__medianVoter, playerI, playerJ, self.__maxDifferenceBetweenPositions, self.__risks[j] ).calculate() self.__expectedUtilityJI[i][j] = ( playerJ.salience * (probSucc * usi + (1 - probSucc) * ufi) + (1 - playerJ.salience) * usi - probSQ * usq - (1 - probSQ) * (T * ubi + (1 - T) * uwi) ) print("====E(Uij) =====") tablePrint(self.__expectedUtilityIJ) print("====E(Uji) =====") tablePrint(self.__expectedUtilityJI)