source: src/main/java/agents/ai2014/group12/Preference.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.Domain;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.Objective;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;
import genius.core.utility.AdditiveUtilitySpace;
import genius.core.utility.Evaluator;
import genius.core.utility.EvaluatorDiscrete;

/**
 * The Preference class will hold the issues, their weights and for each issue
 * their values and the order of these values. Only compatible with
 * {@link AdditiveUtilitySpace}.
 *
 */
public class Preference {
        ArrayList<PreferenceBlock> preferenceList = new ArrayList<PreferenceBlock>();

        /**
         * First constructor for the Preference class, this is to create a
         * Preference profile for the agent that is currently in turn. This
         * Preference object will not be updated. The Utilityspace is used to fill
         * the values of each issue and their order.
         * 
         * @param utilitySpace
         *            of the player in turn
         */
        public Preference(AdditiveUtilitySpace utilitySpace) {
                Domain domain = utilitySpace.getDomain();
                int size = utilitySpace.getEvaluators().size();
                System.out.println("size: " + size);
                List<Objective> objectives = domain.getObjectives();
                for (int i = 1; i <= size; i++) {
                        IssueDiscrete issue = (IssueDiscrete) objectives.get(i);
                        Double weight = utilitySpace.getWeight(i);
                        Evaluator evalor = utilitySpace.getEvaluator(i);
                        EvaluatorDiscrete evalorDis = (EvaluatorDiscrete) evalor;
                        // Define each issue with every weight attached
                        PreferenceBlock prefBlock = new PreferenceBlock(evalorDis,
                                        issue.getName(), weight);
                        prefBlock.normalizeNodeValues();
                        Node highest = prefBlock.getHighestPreference();
                        highest.setFlag(true);
                        preferenceList.add(prefBlock);
                }
                // Possibility to randomize the other values of each issue.
        }

        /**
         * This constructor is used to create a Preference object for an Agent of
         * which you have received a bid for the first time. The utilitySpace of the
         * agent receiving the message will be used for the initial issue, value and
         * order setup. This will be later updated using the bids of the agent to
         * which this preference belongs to.
         * 
         * @param utilitySpace
         *            of the agent receiving the message
         * @param bid
         */
        public Preference(AdditiveUtilitySpace utilitySpace, Bid bid) {
                Domain domain = utilitySpace.getDomain();
                int size = utilitySpace.getEvaluators().size();
                System.out.println("size: " + size);
                List<Objective> objectives = domain.getObjectives();
                for (int i = 1; i <= size; i++) {
                        IssueDiscrete issue = (IssueDiscrete) objectives.get(i);
                        double weight = 1.0 / size;
                        Evaluator evalor = utilitySpace.getEvaluator(i);
                        System.out.println(evalor);
                        EvaluatorDiscrete evalorDis = (EvaluatorDiscrete) evalor;
                        // Define an issue with all weights the same
                        PreferenceBlock prefBlock = new PreferenceBlock(evalorDis,
                                        issue.getName(), weight);
                        prefBlock.normalizeNodeValues();
                        Node highest = prefBlock.getHighestPreference();
                        highest.setFlag(true);
                        preferenceList.add(prefBlock);
                }
                setHighestIssuePreference(bid);
                // Possibility to randomize the other values of each issue.
        }

        /**
         * Updates the preference of a party given the current bid. It considers the
         * first bid to be the agents highest utility bid. It will not take into
         * account the nodes flagged value for this first bid.
         * 
         * @param bid
         */
        public void setHighestIssuePreference(Bid bid) {
                HashMap<Integer, Value> values = bid.getValues();
                for (int i = 1; i <= values.size(); i++) {
                        ValueDiscrete value = (ValueDiscrete) values.get(i);
                        PreferenceBlock preferBlock = preferenceList.get(i - 1);
                        Node currentHighest = preferBlock.getHighestPreference();
                        if (!currentHighest.getName().equals(value.getValue())) {
                                // preferBlock.orderNodesLowToHigh();
                                ArrayList<Node> nodes = preferBlock.nodeList;

                                int index = preferBlock.indexOf(value.getValue());

                                for (int j = index; j < nodes.size() - 1; j++) {
                                        nodes.get(j).setName(nodes.get(j + 1).getName());
                                }
                                nodes.get(nodes.size() - 1).setName(value.getValue());
                        }
                }
        }

        /**
         * This method updates the preference order of an already initialized
         * preference object This will used the flagged status to determine what
         * nodes have alreay been set. It will determine what values have been
         * changed and were not yet flagged and will set those in the appropriate
         * order and update their flagged status.
         * 
         * @param bid
         */
        public void updatePreferenceOrder(Bid bid) {
                // First update the sequence of the values of an issue
                HashMap<Integer, Value> values = bid.getValues();
                for (int i = 1; i <= values.size(); i++) {
                        ValueDiscrete value = (ValueDiscrete) values.get(i);
                        PreferenceBlock preferBlock = preferenceList.get(i - 1);
                        ArrayList<Node> nodesWithoutFlag = preferBlock
                                        .getValuesWithoutFlag();
                        for (int j = 0; i < nodesWithoutFlag.size(); i++) {
                                // If not flagged yet, flag it and set it to the next value
                                // after the last flagged
                                if (nodesWithoutFlag.get(i).getName().equals(value.getValue())) {
                                        int highestIndexWithoutFlag = preferBlock
                                                        .getHighestIndexWithoutFlag();

                                        ArrayList<Node> nodes = preferBlock.nodeList;
                                        int index = preferBlock.indexOf(value.getValue());

                                        for (int k = index; k < nodes.size() - 1
                                                        && !nodes.get(k + 1).getFlag(); k++) {
                                                nodes.get(k).setName(nodes.get(k + 1).getName());
                                        }
                                        nodes.get(highestIndexWithoutFlag)
                                                        .setName(value.getValue());
                                        nodes.get(highestIndexWithoutFlag).setFlag(true);
                                }
                        }
                }
        }

        /**
         * This method updates the issue weights given the previous bid and the new
         * bid. Each weight of an issue that has been changed will be decreased and
         * then normalized.
         * 
         * @param previousBids
         * @param newBid
         */
        public void updateIssueWeights(ArrayList<Bid> previousBids, Bid newBid) {
                Bid previousBid = previousBids.get(previousBids.size() - 1);
                ArrayList<Integer> changedIssues = getChangedIndices(previousBid,
                                newBid);

                // Decrease the weights that have been changed
                for (int i = 0; i < changedIssues.size(); i++) {
                        preferenceList.get(changedIssues.get(i)).weight -= 0.50 / changedIssues
                                        .size();
                }

                // Sum the weights
                double sum = 0.0;
                for (int i = 0; i < preferenceList.size(); i++) {
                        sum += preferenceList.get(i).weight;
                }
                // Normalize the weights
                for (int i = 0; i < preferenceList.size(); i++) {
                        preferenceList.get(i).weight = preferenceList.get(i).weight / sum;
                }
        }

        /**
         * Method that returns the changed indices by comparing the previous bid and
         * the new bid
         * 
         * @param previousBid
         * @param newBid
         * @return list of integers with the changed indices
         */
        public ArrayList<Integer> getChangedIndices(Bid previousBid, Bid newBid) {
                ArrayList<Integer> indices = new ArrayList<Integer>();
                HashMap<Integer, Value> valuesNewBid = newBid.getValues();
                HashMap<Integer, Value> valuesPreviousBid = previousBid.getValues();
                for (int i = 1; i <= valuesNewBid.size(); i++) {
                        ValueDiscrete valueNewBid = (ValueDiscrete) valuesNewBid.get(i);
                        ValueDiscrete valuePreviousBid = (ValueDiscrete) valuesPreviousBid
                                        .get(i);
                        if (!valueNewBid.getValue().equals(valuePreviousBid.getValue())) {
                                // i-1 to get the right index in the preferenceList
                                indices.add(i - 1);
                        }
                }
                return indices;
        }

        /**
         * Calculates the utility value for a bid given the current preference
         * profile. This gives the agent the possibility to calculate other agents
         * utilities without knowing their exact preference profile.
         * 
         * @param bid
         * @return double
         */
        public double getUtilityValue(Bid bid) {
                HashMap<Integer, Value> bidvalues = bid.getValues();
                double returnUtility = 0;
                for (PreferenceBlock block : preferenceList) {
                        double weight = block.weight;
                        for (Map.Entry<Integer, Value> entry : bidvalues.entrySet()) {
                                Value value = entry.getValue();
                                for (Node node : block.nodeList) {
                                        if (node.getName() == value.toString()) {
                                                returnUtility += node.getValue() * weight;
                                        }
                                }
                        }
                }
                return returnUtility;
        }
}