source: src/main/java/agents/anac/y2011/IAMhaggler2011/RandomBidCreator.java

package agents.anac.y2011.IAMhaggler2011;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

import genius.core.Bid;
import genius.core.Domain;
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.ValueInteger;
import genius.core.issue.ValueReal;
import genius.core.utility.AdditiveUtilitySpace;

public class RandomBidCreator implements BidCreator {

        protected Random random;
        private boolean TEST_EQUIVALENCE = false;

        public RandomBidCreator() {
                if (TEST_EQUIVALENCE) {
                        random = new Random(100);
                } else {
                        random = new Random();
                }
        }

        /**
         * Get a random bid.
         * 
         * @param utilitySpace
         *            The utility space to generate the random bid from.
         * @return a random bid.
         */
        private Bid getRandomBid(AdditiveUtilitySpace utilitySpace) {
                Domain domain = utilitySpace.getDomain();
                HashMap<Integer, Value> values = new HashMap<Integer, Value>();
                List<Issue> issues = domain.getIssues();
                Bid bid = null;
                for (Iterator<Issue> iterator = issues.iterator(); iterator.hasNext();) {
                        Issue issue = (Issue) iterator.next();
                        switch (issue.getType()) {
                        case DISCRETE:
                                generateValue(values, (IssueDiscrete) issue);
                                break;

                        case REAL:
                                generateValue(values, (IssueReal) issue);
                                break;

                        case INTEGER:
                                generateValue(values, (IssueInteger) issue);
                                break;
                        }
                }

                try {
                        bid = new Bid(domain, values);
                } catch (Exception e) {
                }
                return bid;
        }

        protected void generateValue(HashMap<Integer, Value> values,
                        IssueDiscrete issue) {
                int randomDiscrete = random.nextInt(issue.getNumberOfValues());
                values.put(Integer.valueOf(issue.getNumber()),
                                issue.getValue(randomDiscrete));
        }

        protected void generateValue(HashMap<Integer, Value> values, IssueReal issue) {
                double randomReal = issue.getLowerBound() + random.nextDouble()
                                * (issue.getUpperBound() - issue.getLowerBound());
                values.put(Integer.valueOf(issue.getNumber()),
                                new ValueReal(randomReal));
        }

        protected void generateValue(HashMap<Integer, Value> values,
                        IssueInteger issue) {
                int randomInteger = issue.getLowerBound()
                                + random.nextInt(issue.getUpperBound() - issue.getLowerBound()
                                                + 1);
                values.put(Integer.valueOf(issue.getNumber()), new ValueInteger(
                                randomInteger));
        }

        /**
         * Get a random bid (above a minimum utility value if possible).
         * 
         * @param utilitySpace
         *            The utility space to generate the random bid from.
         * @param min
         *            The minimum utility value.
         * @return a random bid (above a minimum utility value if possible).
         */
        private Bid getRandomBid(AdditiveUtilitySpace utilitySpace, double min) {
                int i = 0;
                while (true) {
                        Bid b = getRandomBid(utilitySpace);
                        try {
                                double util = utilitySpace.getUtility(b);
                                if (util >= min) {
                                        // printVal(util);
                                        return b;
                                }
                        } catch (Exception e) {
                        }
                        i++;
                        if (i == 500) {
                                min -= 0.01;
                                i = 0;
                        }
                }
        }

        /**
         * Get a random bid (within a utility range if possible).
         * 
         * @param utilitySpace
         *            The utility space to generate the random bid from.
         * @param min
         *            The minimum utility value.
         * @param max
         *            The maximum utility value.
         * @return a random bid (within a utility range if possible).
         */
        public Bid getRandomBid(AdditiveUtilitySpace utilitySpace, double min,
                        double max) {
                int i = 0;
                while (true) {
                        if (max >= 1) {
                                return getRandomBid(utilitySpace, min);
                        }
                        Bid b = getRandomBid(utilitySpace);
                        try {
                                double util = utilitySpace.getUtility(b);
                                if (util >= min && util <= max) {
                                        // printVal(util);
                                        return b;
                                }
                        } catch (Exception e) {
                        }
                        i++;
                        if (i == 500) {
                                max += 0.01;
                                i = 0;
                        }
                }
        }

        @Override
        public Bid getBid(AdditiveUtilitySpace utilitySpace, double min, double max) {
                return getRandomBid(utilitySpace, min, max);
        }
}