source: src/main/java/agents/OptimalBidderSimpleU.java

/** 
 *      OptimalBidder: using the optimal stopping rule (cutoffs) for bidding. 
 *      B_{j+1} = 1/2 + 1/2 B_j^2
 * @author rafik                
 ************************************************************************************************************************************/

package agents;

import java.util.HashMap;

import genius.core.issue.ISSUETYPE;
import genius.core.issue.IssueDiscrete;
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;

public class OptimalBidderSimpleU extends OptimalBidderU {
        private static double rvB;

        public void init() {
                partitions = 1000;
                super.init();
        }

        @Override
        public String getName() {
                return "OptimalBidderSimpleU";
        }

        /**
         * computation of the bid for round j as in prop 4.3
         * 
         * @param round
         *            j
         * @return bid value
         **/
        @Override
        public double bid(int j) {
                if (j == 1)
                        return 0.5 + 0.5 * rvB;
                else
                        return 0.5 + 0.5 * Math.pow(bid(j - 1), 2);
        }

        /**
         * reservation value: if the reservation value is already set (<> -1.0)
         * simply return it, otherwise get it from the utility space
         * 
         * @param double
         * @return double
         * @throws Exception
         **/
        @Override
        public double getReservationValue(double arg) throws Exception {
                boolean flag = true;
                double rv = 0.0;

                if (arg == -1.0) // first time // TODO rmeove the -1, rv, etc.
                {
                        if (pie.getType().equals(ISSUETYPE.DISCRETE)) // get/set rvB...
                        {
                                IssueDiscrete discrete_pie = (IssueDiscrete) pie;
                                int nvalues = discrete_pie.getNumberOfValues();
                                print("   nvalues = " + nvalues);
                                values = new HashMap<Integer, Value>(nvalues);

                                for (int i = 0; i < nvalues; i++) {
                                        ValueDiscrete value = discrete_pie.getValue(i);
                                        Evaluator evaluator = ((AdditiveUtilitySpace) utilitySpace)
                                                        .getEvaluator(pie.getNumber());
                                        Integer evaluation = ((EvaluatorDiscrete) evaluator)
                                                        .getValue((ValueDiscrete) value);
                                        values.put(i, value);

                                        if (evaluation != 0 && flag) // reaching rvB
                                        {
                                                rv = (double) i / partitions; // rvB normalized
                                                utilitySpace.setReservationValue(rv); // TODO no need
                                                                                                                                // for this,
                                                                                                                                // remove it.
                                                flag = false;
                                                print("   rvB = " + rv);
                                        }
                                }
                                return rv;
                        } else {
                                throw new Exception("Type " + pie.getType()
                                                + " not supported by " + getName());
                        }
                } else {
                        return arg;
                }
        }

        /**
         * U_{j+1} : utility cutoffs
         * 
         * @param int
         * @return double
         * @throws Exception
         **/

        @Override
        public double utility(int j) {
                return (Math.pow(bid(j), 2) - rvB) / (1 - rvB);
        }

} // end