source: src/main/java/agents/anac/y2010/AgentSmith/IssueModel.java

package agents.anac.y2010.AgentSmith;

import java.util.ArrayList;
import java.util.HashMap;

import genius.core.Bid;
import genius.core.issue.Issue;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;
import genius.core.issue.ValueInteger;
import genius.core.issue.ValueReal;

/**
 * Model of one issue, takes all values of the opponent on this issue. Then the
 * utility and it's weight can be calculated on this issue. In the OpponentModel
 * this information is used to determine the utility of the other party.
 */
public class IssueModel {
        private ArrayList<Value> fValues;
        private Issue fIssue;
        private Bounds fBounds;

        /**
         * Constructor
         * 
         * @param lIssue
         */
        public IssueModel(Issue lIssue) {
                fValues = new ArrayList<Value>();
                fIssue = lIssue;
                fBounds = new Bounds(fIssue);
        }

        /**
         * The mean of the values in the values list.
         */
        public double getAverage() {
                double lTotal = 0;
                for (Value lWeight : fValues) {
                        lTotal += getNumberValue(lWeight);
                }
                return lTotal / fValues.size();
        }

        /**
         * The standard deviation utility of the issues.
         */
        public double getDeviation() {
                double lIssueAverage = getAverage();
                double lTotal = 0;
                for (Value lWeight : fValues) {
                        lTotal += Math.pow(getNumberValue(lWeight) - lIssueAverage, 2);
                }

                return Math.sqrt(lTotal / (double) fValues.size());
        }

        /**
         * Add a value to the list
         */
        public void addValue(Value pValue) {
                fValues.add(pValue);
        }

        /**
         * The value of an issue in a double type
         */
        public double getNumberValue(Value pValue) {
                switch (fIssue.getType()) {
                case DISCRETE:
                        throw new RuntimeException("No get value for discret");
                case REAL:
                        return ((ValueReal) pValue).getValue();
                case INTEGER:
                        return ((ValueInteger) pValue).getValue();
                default:
                        return 0;
                }

        }

        /**
         * The utility of a bid, which can be real, integer or discrete
         */
        public double getUtility(Bid pBid) {
                double lUtility = 0;
                switch (fIssue.getType()) {
                case INTEGER:
                        lUtility = getRealUtility(pBid);
                        break;
                case REAL:
                        lUtility = getRealUtility(pBid);
                        break;
                case DISCRETE:
                        lUtility = getDiscreteUtility(pBid);
                        break;
                }

                return lUtility;
        }

        /**
         * The utility of if this issue is discrete. Takes the amount of values that
         * are the same and divides it by the total amount of values. If there are
         * lots of same values as the bid, the utility will be high, else it will be
         * low.
         */
        public double getDiscreteUtility(Bid pBid) {
                double lSame = 0;
                for (Value lValue : fValues) {
                        ValueDiscrete lDiscreteValue = (ValueDiscrete) lValue;
                        if (lDiscreteValue.getValue().equals(
                                        ((ValueDiscrete) getBidValue(pBid)).getValue())) {
                                lSame++;
                        }
                }
                return this.fValues.size() == 0 ? 0 : lSame
                                / (double) this.fValues.size();
        }

        /**
         * The utility of a bid in the real or integer case
         */
        public double getRealUtility(Bid pBid) {
                return 1 - Math.abs(fBounds
                                .normalize(getNumberValue(getBidValue(pBid)))
                                - fBounds.normalize(getAverage()));
        }

        /**
         * Get's the importance of this issues utility
         */
        public double getWeight() {
                double lWeight = 0;
                switch (fIssue.getType()) {
                case INTEGER:
                        lWeight = getRealWeight();
                        break;
                case REAL:
                        lWeight = getRealWeight();
                        break;
                case DISCRETE:
                        lWeight = getDiscreteWeight();
                        break;
                }

                return lWeight;
        }

        /**
         * Gets the weight of this value. If there are lots of changes, it's not
         * important, else it is important.
         */
        public double getDiscreteWeight() {
                HashMap<String, Integer> lCounter = new HashMap<String, Integer>();
                for (Value lValue : fValues) {
                        ValueDiscrete lDiscreteValue = (ValueDiscrete) lValue;
                        int lCount = lCounter.get(lDiscreteValue.getValue()) != null ? lCounter
                                        .get(lDiscreteValue.getValue()) : 0;
                        lCount++;
                        lCounter.put(lDiscreteValue.getValue(), lCount);
                }
                double lMax = 0;
                double lTotal = 0;

                for (int lC : lCounter.values()) {
                        if (lC > lMax)
                                lMax = lC;
                        lTotal += lC;
                }

                return lMax / lTotal;
        }

        /**
         * returns the real (or integer) weight
         */
        public double getRealWeight() {
                return 1 / (1 + getDeviation());
        }

        /**
         * returns the value of a bid
         */
        public Value getBidValue(Bid pBid) {
                return getBidValueByIssue(pBid, fIssue);
        }

        /**
         * returns the value of an issue in a bid
         */
        public static Value getBidValueByIssue(Bid pBid, Issue pIssue) {
                Value lValue = null;
                try {
                        lValue = pBid.getValue(pIssue.getNumber());
                } catch (Exception e) {
                }

                return lValue;

        }
}