source: src/main/java/agents/anac/y2010/AgentSmith/Bounds.java@ 1

package agents.anac.y2010.AgentSmith;

import java.util.HashMap;
import java.util.List;

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

/**
 * Class that is used to determine the bounds of an issue.
 */
public class Bounds {
        private double fLower;
        private double fUpper;
        private double fAmtSteps;

        /**
         * Constructor
         */
        public Bounds() {
        }

        /**
         * Constructor. Sets the bounds for a given issue based on its type
         * (discrete, real or integer)
         */
        public Bounds(Issue pIssue) {
                switch (pIssue.getType()) {
                case DISCRETE:
                        IssueDiscrete lIssueDiscrete = ((IssueDiscrete) pIssue);
                        setUpper(lIssueDiscrete.getNumberOfValues());
                        setLower(0);
                        setAmtSteps(lIssueDiscrete.getNumberOfValues());
                        break;
                case REAL:
                        IssueReal lIssueReal = ((IssueReal) pIssue);
                        setUpper(lIssueReal.getUpperBound());
                        setLower(lIssueReal.getLowerBound());
                        setAmtSteps(10);
                        break;
                case INTEGER:
                        IssueInteger lIssueInteger = ((IssueInteger) pIssue);
                        setUpper(lIssueInteger.getUpperBound());
                        setLower(lIssueInteger.getLowerBound());
                        setAmtSteps(10);
                        break;
                }
        }

        /**
         * returns the lower bound
         */
        public double getLower() {
                return fLower;
        }

        /**
         * returns the upper bound
         */
        public double getUpper() {
                return fUpper;
        }

        /**
         * returns the amount of steps
         */
        public double getAmtSteps() {
                return fAmtSteps;
        }

        /**
         * returns the number of steps
         */
        public double getStepSize() {
                return (fUpper - fLower) / fAmtSteps;
        }

        /**
         * sets the lower bound
         */
        public void setLower(double pLower) {
                this.fLower = pLower;
        }

        /**
         * sets the upper bound
         */
        public void setUpper(double pUpper) {
                this.fUpper = pUpper;
        }

        /**
         * set the number of steps to take
         */
        public void setAmtSteps(double pAmtSteps) {
                this.fAmtSteps = pAmtSteps;
        }

        /**
         * Creates a hashmap with for each of the issues the bounds
         */
        public static HashMap<Integer, Bounds> getIssueBounds(List<Issue> pIssues) {
                HashMap<Integer, Bounds> bounds = new HashMap<Integer, Bounds>();

                for (Issue lIssue : pIssues) {
                        Bounds b = new Bounds(lIssue);

                        bounds.put(lIssue.getNumber(), b);

                }
                return bounds;
        }

        /**
         * returns a Value object with the value of an issue at the given index
         * works for real, discrete and integer objects
         */
        public static Value getIssueValue(Issue pIssue, double pIndex) {
                Value v = null;
                switch (pIssue.getType()) {
                case DISCRETE:
                        v = ((IssueDiscrete) pIssue).getValue((int) pIndex);
                        break;
                case REAL:
                        v = new ValueReal(pIndex);
                        break;
                case INTEGER:
                        v = new ValueInteger((int) pIndex);
                        break;
                }
                return v;
        }

        /**
         * returns the scaled value of the (discrete, real or integer) issue. it is
         * scaled by the difference between the value and the lower bound divided by
         * the length of the bounds
         */
        public static double getScaledIssueValue(Bounds pBounds, Bid pBid,
                        Issue pIssue) throws Exception {

                Value v = pBid.getValue(pIssue.getNumber());

                double value = 0;

                switch (pIssue.getType()) {
                case DISCRETE:
                        value = ((IssueDiscrete) pIssue).getValueIndex(((ValueDiscrete) v)
                                        .getValue());
                        break;
                case REAL:
                        value = ((ValueReal) v).getValue();
                        break;
                case INTEGER:
                        value = ((ValueInteger) v).getValue();
                        break;
                }

                return (value - pBounds.getLower())
                                / (pBounds.getUpper() - pBounds.getLower());

        }

        /**
         * returns a normalized version of a value
         */
        public double normalize(double pValue) {
                return (pValue - getLower()) / (getUpper() - getLower());
        }

        /**
         * returns a string with the upper and lower bounds
         */
        public String toString() {
                return "Upper: " + getUpper() + " Lower: " + getLower();
        }

}