source: src/main/java/agents/ParetoFrontierPlus.java@ 346

package agents;

import genius.core.Bid;
import genius.core.BidIterator;
import genius.core.analysis.BidPoint;
import genius.core.analysis.ParetoFrontier;
import genius.core.utility.AdditiveUtilitySpace;
import genius.core.utility.UtilitySpace;

/**
 * Like {@link ParetoFrontier}, but with extra functionality. This version loads
 * the frontier by itself using the given utility spaces.
 * 
 * <h1>notes</h1>We may decide to move these functions into
 * {@link ParetoFrontier}.
 * 
 * When a utility space changes, you currently just need to make a new
 * {@link ParetoFrontierPlus} from scratch using the constructor. This is
 * because we can not listen to changes in {@link AdditiveUtilitySpace}s
 * 
 * @author W.Pasman 3sep14
 *
 */
public class ParetoFrontierPlus {
        UtilitySpace mySpace, otherSpace;
        private ParetoFrontier pareto = null;

        /**
         * Get a {@link ParetoFrontier} for this outcome space.
         * 
         * @throws Exception
         */
        public ParetoFrontierPlus(UtilitySpace spaceMe, UtilitySpace spaceOther) {
                mySpace = spaceMe;
                otherSpace = spaceOther;
                try {
                        computeParetoFrontier();
                } catch (Exception e) {
                        throw new IllegalStateException(
                                        "Failed to compute Pareto Frontier", e);
                }
        }

        /**
         * compute the pareto frontier. Warning, this may take some time and may
         * even run out of memory if the space is really large.
         * 
         * @throws Exception
         *             if getUtility fails.
         * */
        private void computeParetoFrontier() throws Exception {
                Bid bid;

                BidIterator bids = new BidIterator(mySpace.getDomain());
                pareto = new ParetoFrontier();
                while (bids.hasNext()) {
                        bid = bids.next();
                        BidPoint bp = new BidPoint(bid, mySpace.getUtility(bid),
                                        otherSpace.getUtility(bid));
                        pareto.mergeIntoFrontier(bp);
                }

                pareto.sort();
        }

        /**
         * Project a utility onto a pareto frontier point
         * 
         * @param otherUtil
         *            the utility that the projected point should be close to.
         * @return a {@link BidPoint} on the pareto that has minimal distance to the
         *         given otherUtil.
         */
        public BidPoint getBidNearOpponentUtility(double otherUtil) {
                BidPoint nearest = null;
                double dist = 10; // larger than any real distance in utilspace.
                for (BidPoint bidpoint : pareto.getFrontier()) {
                        double newdist = Math.abs(bidpoint.getUtilityB() - otherUtil);
                        if (newdist < dist) {
                                nearest = bidpoint;
                                dist = newdist;
                        }
                }
                return nearest;
        }

        /**
         * get the bid on the pareto that has myUtility nearest to given target
         * utility
         * 
         * @param bid
         * @return
         */
        public BidPoint getBidNearMyUtility(double utility) {
                BidPoint nearest = null;
                double dist = 10; // larger than any real distance in utilspace.
                for (BidPoint bidpoint : pareto.getFrontier()) {
                        double newdist = Math.abs(bidpoint.getUtilityA() - utility);
                        if (newdist < dist) {
                                nearest = bidpoint;
                                dist = newdist;
                        }
                }
                return nearest;

        }

        /**
         * get the bid on the pareto that has at least the given utility for me (as
         * close as possible to the target)
         * 
         * @param utility
         *            target utility for me.
         * @return bid that is nearest bid above or at target utility for me. May
         *         return null if no such bid.
         */

        public BidPoint getBidWithMinimumUtility(double utility) {
                BidPoint nearest = null;
                double dist = 10; // larger than any real distance in utilspace.
                double newdist;
                for (BidPoint bidpoint : pareto.getFrontier()) {
                        newdist = bidpoint.getUtilityA() - utility;
                        if (newdist > 0 && newdist < dist) {
                                nearest = bidpoint;
                                dist = newdist;
                        }
                }
                return nearest;
        }
}