source: src/main/java/agents/ai2014/group12/BidGenerator.java@ 127

package agents.ai2014.group12;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import genius.core.Bid;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;
import genius.core.utility.AbstractUtilitySpace;

public class BidGenerator {
        static ArrayList<Bid> bidCombinations;
        static AbstractUtilitySpace utilitySpace;

        /**
         * This function returns the best bid that an agent can make with regards to
         * other agents.
         * 
         * @param ut
         * @param preference
         * @param acceptingValue
         * @param otherAgentsPreference
         * @return
         * @throws Exception
         */

        public static Bid generateBid(AbstractUtilitySpace ut,
                        Preference preference, double acceptingValue,
                        HashMap<String, Preference> otherAgentsPreference) throws Exception {
                System.out.println("Begin combinations");
                utilitySpace = ut;
                bidCombinations = new ArrayList<Bid>();

                if (acceptingValue == 0.9) {
                        return ut.getMaxUtilityBid();
                }

                cartesianProductW(preference);

                ArrayList<Bid> filteredBidCombinations = filterCombos(acceptingValue,
                                0.1);

                Bid returnBid = new Bid(ut.getDomain());
                returnBid = getBestBid(filteredBidCombinations, ut, preference,
                                otherAgentsPreference);

                return returnBid;
        }

        /**
         * A wrapper function for the cartesianProduct of a agents preferences. Will
         * make a List<List<Node>> data structured that will be used as input for
         * cartesianProduct
         * 
         * @param preference
         * @throws Exception
         */

        private static void cartesianProductW(Preference preference)
                        throws Exception {
                List<List<Node>> blocks = new ArrayList<List<Node>>();

                for (int i = 0; i < preference.preferenceList.size(); i++) {
                        PreferenceBlock block = preference.preferenceList.get(i);
                        List<Node> nodes = new ArrayList<Node>();
                        for (int j = 0; j < block.nodeList.size(); j++) {
                                nodes.add(block.nodeList.get(j));
                        }
                        blocks.add(nodes);
                }

                List<List<Node>> resultTest = cartesianProduct(blocks);
                for (int i = 0; i < resultTest.size(); i++) {
                        List<Node> list = resultTest.get(i);
                        HashMap<Integer, Value> hsmp = new HashMap<Integer, Value>();
                        Bid bid = new Bid(utilitySpace.getDomain());
                        for (int j = 0; j < list.size(); j++) {
                                Node node = list.get(j);
                                ValueDiscrete val = new ValueDiscrete(node.getName());
                                Value value = (Value) val;
                                hsmp.put(j + 1, value);
                                bid = new Bid(utilitySpace.getDomain(), hsmp);
                        }
                        bidCombinations.add(bid);
                }
        }

        /**
         * Will return a cartesianProduct list of the input list
         * 
         * @param lists
         * @return
         */
        protected static <T> List<List<T>> cartesianProduct(List<List<T>> lists) {
                List<List<T>> resultLists = new ArrayList<List<T>>();
                if (lists.size() == 0) {
                        resultLists.add(new ArrayList<T>());
                        return resultLists;
                } else {
                        List<T> firstList = lists.get(0);
                        List<List<T>> remainingLists = cartesianProduct(lists.subList(1,
                                        lists.size()));
                        for (T condition : firstList) {
                                for (List<T> remainingList : remainingLists) {
                                        ArrayList<T> resultList = new ArrayList<T>();
                                        resultList.add(condition);
                                        resultList.addAll(remainingList);
                                        resultLists.add(resultList);
                                }
                        }
                }
                return resultLists;
        }

        /**
         * Returns the best bid of the bid list, will calculate all the values of
         * the bids and takes the best average bid for everybody and returns that
         * Bid.
         * 
         * @param bids
         * @param ut
         * @param preference
         * @param otherAgentsPreference
         * @return
         * @throws Exception
         */
        private static Bid getBestBid(ArrayList<Bid> bids, AbstractUtilitySpace ut,
                        Preference preference,
                        HashMap<String, Preference> otherAgentsPreference) throws Exception {
                ArrayList<ArrayList<Double>> list = new ArrayList<ArrayList<Double>>();
                for (Bid bid : bids) {
                        ArrayList<Double> bidValues = new ArrayList<Double>();
                        for (Map.Entry<String, Preference> entry : otherAgentsPreference
                                        .entrySet()) {
                                Preference p = (Preference) entry.getValue();
                                double bidValueP = p.getUtilityValue(bid);
                                bidValues.add(bidValueP);
                        }
                }

                ArrayList<Double> averageValueOfBid = new ArrayList<Double>();
                for (ArrayList<Double> listOfABid : list) {
                        double averageWeight = 0;
                        for (double bidListValues : listOfABid) {
                                averageWeight += bidListValues;
                        }
                        averageValueOfBid.add(averageWeight);
                }

                int returnIndex = 0;
                double biggest = 0;
                for (int i = 0; i < averageValueOfBid.size(); i++) {
                        if (averageValueOfBid.get(i) > biggest) {
                                biggest = averageValueOfBid.get(i);
                                returnIndex = i;
                        }
                }
                return bids.get(returnIndex);
        }

        /**
         * Returns an filtered list of the bidcombinations. The filter is an range
         * from the accepting value to a range percentage above the accepting value.
         * 
         * @param acceptingValue
         * @param range
         * @return
         * @throws Exception
         */
        public static ArrayList<Bid> filterCombos(double acceptingValue,
                        double range) throws Exception {
                ArrayList<Bid> goodBidCombos = new ArrayList<Bid>();

                double minValue = acceptingValue;
                double maxValue = acceptingValue + (acceptingValue * range);

                for (int i = 0; i < bidCombinations.size(); i++) {
                        Bid bid = bidCombinations.get(i);
                        double value = utilitySpace.getUtility(bid);
                        if (minValue < value && maxValue > value) {
                                goodBidCombos.add(bid);

                        }
                }

                if (goodBidCombos.size() != 0) {
                        return goodBidCombos;
                } else
                        return filterCombos(acceptingValue, range * 1.5);

        }
}