source: src/main/java/agents/anac/y2012/IAMhaggler2012/utility/SouthamptonUtilitySpace.java

package agents.anac.y2012.IAMhaggler2012.utility;

import java.util.Enumeration;
import java.util.HashMap;

import genius.core.Bid;
import genius.core.issue.Objective;
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;

public class SouthamptonUtilitySpace {
        
        AdditiveUtilitySpace us;

        public SouthamptonUtilitySpace(AdditiveUtilitySpace us) {
                super();
                this.us = us;
        }

        /**
         * @return a bid with the maximum utility value attainable in this util space
         * @throws Exception
         * @author C.R.Williams
         */
        public final Bid getMaxUtilityBid() throws Exception
        {
        HashMap<Integer, Value> bid = new HashMap<Integer, Value>();
        
        Objective root = us.getDomain().getObjectivesRoot();
        Enumeration<Objective> issueEnum = root.getPreorderIssueEnumeration();
        while(issueEnum.hasMoreElements()){
                Objective is = issueEnum.nextElement();
                bid.put(is.getNumber(), getMaxValue(is.getNumber()));
        }

                return new Bid(us.getDomain(), bid);
        }

    /**
     * @param pIssueIndex the index of the issue to get the maximum value for
     * @return a value that maximises the utility of the issue with the given index 
         * @author C.R.Williams
     */
    private Value getMaxValue(int pIssueIndex)
    {
        Evaluator lEvaluator = us.getEvaluator(pIssueIndex);
        if(lEvaluator.getClass() == EvaluatorDiscrete.class)
        {
                return ((EvaluatorDiscrete)lEvaluator).getMaxValue();
        }
        if(lEvaluator.getClass() == EvaluatorInteger.class)
        {
                return getMaxValueInteger((EvaluatorInteger)lEvaluator);
        }
        if(lEvaluator.getClass() == EvaluatorReal.class)
        {
                return getMaxValueReal((EvaluatorReal)lEvaluator);
        }
                return null;
        }
    
    /**
     * @return a value that maximises the utility
         * @author C.R.Williams
     */
        private Value getMaxValueInteger(EvaluatorInteger eval) {
                double utility = 0;     
                switch(eval.getFuncType()) {
                case LINEAR:
                        utility = maxLinear(eval.getSlope(), eval.getOffset());
                        if (utility < eval.getLowerBound())
                                utility = eval.getLowerBound();
                        else if (utility > eval.getUpperBound())
                                utility = eval.getUpperBound();
                        break;
                default:
                        return null;
                }
                return new ValueInteger((int)utility);
        }
        
    /**
     * @return a value that maximises the utility
         * @author C.R.Williams
     */
        private Value getMaxValueReal(EvaluatorReal eval) {
                double utility = 0;     
                switch(eval.getFuncType()) {
                case LINEAR:
                        utility = maxLinear(eval.getLinearParam(), eval.getConstantParam());
                        if (utility < eval.getLowerBound())
                                utility = eval.getLowerBound();
                        else if (utility > eval.getUpperBound())
                                utility = eval.getUpperBound();
                        break;
                case CONSTANT:
                        utility = eval.getLowerBound();
                        break;
                case TRIANGULAR:
                case TRIANGULAR_VARIABLE_TOP:
                        utility = maxTriangular(eval.getLinearParam(), eval.getConstantParam(), eval.getTopParam());
                        break;
                default:
                        return null;
                }
                return new ValueReal(utility);
        }
        
        private static double maxLinear(double coef1, double coef0) {
                if(coef1 > 0)
                        return Double.MAX_VALUE;
                else
                        return Double.MIN_VALUE;
        }
        
        private static double maxTriangular(double lowerBound, double upperBound, double top) {
                return top;
        }
}