package agents.anac.y2012.AgentLG; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import genius.core.AgentID; import genius.core.Bid; import genius.core.actions.Action; import genius.core.actions.Offer; import genius.core.issue.Issue; import genius.core.issue.Value; import genius.core.issue.ValueInteger; import genius.core.issue.ValueReal; import genius.core.utility.AdditiveUtilitySpace; import genius.core.utility.Evaluator; import genius.core.utility.EvaluatorDiscrete; import genius.core.utility.EvaluatorInteger; import genius.core.utility.EvaluatorReal; /** * Class that is used to choose a bid . * * Requires {@link Evaluator}s and thus only works with * {@link AdditiveUtilitySpace} */ public class BidChooser { private AdditiveUtilitySpace utilitySpace; private OpponentBids opponentBids; private ArrayList allBids = null; private Bid maxLastOpponentBid; private int numPossibleBids = 0; private int index = 0; private double lastTimeLeft = 0; private AgentID agentID; private int minSize = 160000; private Bid myBestBid = null; public BidChooser(AdditiveUtilitySpace utilitySpace, AgentID agentID, OpponentBids OpponentBids) { this.utilitySpace = utilitySpace; this.agentID = agentID; this.opponentBids = OpponentBids; } private void initBids() { // get all bids allBids = getAllBids(); BidsComparator bidsComparator = new BidsComparator(utilitySpace); // sort the bids in order of highest utility Collections.sort(allBids, bidsComparator); } /** * Calculate the next bid for the agent (from 1/4 most optimal bids) * */ public Action getNextBid(double time) { Action currentAction = null; try { Bid newBid = allBids.get(index); currentAction = new Offer(agentID, newBid); index++; if (index > numPossibleBids) { // the time is over compromising in a high rate if (time >= 0.9) { if (time - lastTimeLeft > 0.008) { double myBestUtility = utilitySpace .getUtility(myBestBid); double oppBestUtility = utilitySpace .getUtility(opponentBids.getOpponentsBids() .get(0)); double avg = (myBestUtility + oppBestUtility) / 2; if (index >= allBids.size()) index = allBids.size() - 1; else if (utilitySpace.getUtility(allBids.get(index)) < avg) { index--; double maxUtilty = 0; int maxBidIndex = numPossibleBids; for (int i = numPossibleBids; i <= index; i++) { // finds the next better bid for the opponent double utiliy = opponentBids .getOpponentBidUtility( utilitySpace.getDomain(), allBids.get(i)); if (utiliy > maxUtilty) { maxUtilty = utiliy; maxBidIndex = i; } } numPossibleBids = maxBidIndex; } else index--; } else index = 0; } else { index = 0; double discount = utilitySpace.getDiscountFactor(); // the time is over compromising in normal rate (0.05) if (time - lastTimeLeft > 0.05) { // compromise only if the opponent is compromising if (utilitySpace.getUtility(opponentBids .getMaxUtilityBidForMe()) > utilitySpace .getUtility(maxLastOpponentBid) || (discount < 1 && time - lastTimeLeft > 0.1)) { // finds the next better bid for the opponent double maxUtilty = 0; for (int i = 0; i <= numPossibleBids; i++) { double utiliy = opponentBids .getOpponentBidUtility( utilitySpace.getDomain(), allBids.get(i)); if (utiliy > maxUtilty) maxUtilty = utiliy; } for (int i = numPossibleBids + 1; i < allBids .size(); i++) { double utiliy = opponentBids .getOpponentBidUtility( utilitySpace.getDomain(), allBids.get(i)); if (utiliy >= maxUtilty) { numPossibleBids = i; break; } } maxLastOpponentBid = opponentBids .getMaxUtilityBidForMe(); lastTimeLeft = time; } } } } } catch (Exception e) { e.printStackTrace(); } return currentAction; } /** * Calculate the next optimal bid for the agent (from 1/4 most optimal bids) * */ public Action getNextOptimicalBid(double time) { Action currentAction = null; Bid newBid = null; try { if (allBids == null) initBids(); newBid = allBids.get(index); currentAction = new Offer(agentID, newBid); index++; double myBestUtility = utilitySpace.getUtilityWithDiscount( myBestBid, time); double oppBestUtility = utilitySpace.getUtilityWithDiscount( opponentBids.getOpponentsBids().get(0), time); double downBond = myBestUtility - (myBestUtility - oppBestUtility) / 4; // check if time passes and compromise a little bit if (time - lastTimeLeft > 0.1 && numPossibleBids < allBids.size() - 1 && downBond <= utilitySpace.getUtilityWithDiscount( allBids.get(numPossibleBids + 1), time)) { double futureUtility = utilitySpace.getUtilityWithDiscount( allBids.get(numPossibleBids), time + 0.1); while (utilitySpace.getUtilityWithDiscount( allBids.get(numPossibleBids), time) >= futureUtility && numPossibleBids < allBids.size() - 1) numPossibleBids++; lastTimeLeft = time; } if (index > numPossibleBids) index = 0; } catch (Exception e) { e.printStackTrace(); } maxLastOpponentBid = opponentBids.getMaxUtilityBidForMe(); return currentAction; } /* * returns the Evaluator of an issue */ public Evaluator getMyEvaluator(int issueID) { return utilitySpace.getEvaluator(issueID); } /* * returns all bids */ private ArrayList getAllBids() { ArrayList bids = new ArrayList(); List issues = utilitySpace.getDomain().getIssues(); HashMap issusesFirstValue = new HashMap(); for (Issue issue : issues) { Value v = getIsuueValues(issue).get(0); issusesFirstValue.put(issue.getNumber(), v); } try { bids.add(new Bid(utilitySpace.getDomain(), issusesFirstValue)); } catch (Exception e) { e.printStackTrace(); } for (Issue issue : issues) { ArrayList tempBids = new ArrayList(); ArrayList issueValues = getIsuueValues(issue); for (Bid bid : bids) { for (Value value : issueValues) { HashMap lNewBidValues = getBidValues(bid); lNewBidValues.put(issue.getNumber(), value); try { Bid newBid = new Bid(utilitySpace.getDomain(), lNewBidValues); tempBids.add(newBid); } catch (Exception e) { e.printStackTrace(); } } } bids = tempBids; } // remove bids that are not good enough (the utility is less the 1/4 of // the difference between the players) double myBestUtility = 1; double oppBestUtility = 0; try { myBestBid = utilitySpace.getMaxUtilityBid(); myBestUtility = utilitySpace.getUtility(myBestBid); oppBestUtility = utilitySpace.getUtility(opponentBids .getOpponentsBids().get(0)); } catch (Exception e1) { e1.printStackTrace(); } return filterBids(bids, myBestUtility, oppBestUtility, 0.75D); } private ArrayList filterBids(ArrayList bids, double myBestUtility, double oppBestUtility, double fraction) { double downBond = myBestUtility - (myBestUtility - oppBestUtility) * fraction; ArrayList filteredBids = new ArrayList(); for (Bid bid : bids) { try { double reservation = utilitySpace.getReservationValue() != null ? utilitySpace .getReservationValue() : 0; if (utilitySpace.getUtility(bid) < downBond || utilitySpace.getUtility(bid) < reservation) continue; else filteredBids.add(bid); } catch (Exception e) { e.printStackTrace(); } } if (filteredBids.size() < minSize) { return filteredBids; } return filterBids(filteredBids, myBestUtility, oppBestUtility, fraction * 0.85D); } /* * returns bid values */ private HashMap getBidValues(Bid bid) { HashMap bidValues = new HashMap(); List allIsuues = utilitySpace.getDomain().getIssues(); for (Issue issue : allIsuues) { try { bidValues.put(issue.getNumber(), bid.getValue(issue.getNumber())); } catch (Exception e) { e.printStackTrace(); } } return bidValues; } /* * returns issue values */ public ArrayList getIsuueValues(Issue issue) { Evaluator e = getMyEvaluator(issue.getNumber()); ArrayList retValues = new ArrayList(); switch (e.getType()) { case DISCRETE: EvaluatorDiscrete eD = ((EvaluatorDiscrete) e); retValues.addAll(eD.getValues()); break; case REAL: EvaluatorReal eR = ((EvaluatorReal) e); double intervalReal = (eR.getUpperBound() - eR.getLowerBound()) / 10; for (int i = 0; i <= 10; i++) { retValues.add(new ValueReal(eR.getLowerBound() + i * intervalReal)); } break; case INTEGER: EvaluatorInteger eI = ((EvaluatorInteger) e); int intervalInteger = (eI.getUpperBound() - eI.getLowerBound()) / 10; for (int i = 0; i <= 10; i++) { retValues.add(new ValueInteger(eI.getLowerBound() + i * intervalInteger)); } break; } return retValues; } /* * returns the minimum utility of the bid that the agent voted */ public double getMyBidsMinUtility(double time) { if (allBids == null) initBids(); return utilitySpace.getUtilityWithDiscount( allBids.get(numPossibleBids), time); } /* * returns the bid with the minimum utility that the agent voted */ public Bid getMyminBidfromBids() { if (allBids == null) initBids(); return allBids.get(numPossibleBids); } /* * returns the bid utility */ public double getUtility(Bid bid) { try { return utilitySpace.getUtility(bid); } catch (Exception e) { e.printStackTrace(); } return 0; } }