source: boa/src/main/java/geniusweb/boa/acceptancestrategy/TimeDependentAcceptanceStrategy.java

package geniusweb.boa.acceptancestrategy;

import geniusweb.actions.Accept;
import geniusweb.actions.Action;
import geniusweb.actions.Offer;
import geniusweb.bidspace.BidsWithUtility;
import geniusweb.boa.BoaState;
import geniusweb.boa.biddingstrategy.TimeDependentBiddingStrategy;
import geniusweb.inform.Settings;
import geniusweb.issuevalue.Bid;
import geniusweb.profile.Profile;
import geniusweb.profile.utilityspace.LinearAdditive;
import geniusweb.profile.utilityspace.UtilitySpace;

/**
 * Simple implementation similar to the {@link TimeDependentBiddingStrategy}.
 * Accepts if the last placed offer is ≥ {@link #p(double)}. Uses 4
 * parameters:
 * <ul>
 * <li>e: the exponent for the target-utility function. See {@link #f(double)}
 * <li>k: the constant for the target-utility function. See {@link #f(double)}
 * <li>max: the maximum utility target used at t=0.
 * <li>min: the minimum utility target used at t=1
 * </ul>
 */
public class TimeDependentAcceptanceStrategy implements AcceptanceStrategy {

        private transient Double min = null, max = null, e = null, k = null; // cache

        @Override
        public Action filter(Action action, BoaState state) {
                Offer lastOffer = state.getLastReceivedOffer();
                if (lastOffer == null || !(action instanceof Offer))
                        return action;
                Bid bid = lastOffer.getBid();
                if (min == null || max == null || e == null || k == null) {
                        min = getMin(state);
                        max = getMax(state);
                        e = getE(state);
                        k = getK(state);
                }
                double targetUtil = p(
                                state.getProgress().get(System.currentTimeMillis()));
                // we subtract epsilon because of rounding errors in computation.
                if (((UtilitySpace) state.getProfile()).getUtility(bid)
                                .doubleValue() >= targetUtil - 0.0000001)
                        return new Accept(state.getSettings().getID(), bid);
                return action;
        }

        /**
         * Overrideable for hard configuring this component.
         * 
         * @param state the {@link BoaState}
         * @return the parameter e for the time depemdency function
         *         {@link #f(double)}. The parameter is 1 by default, or the value
         *         for the "e" parameter in the {@link Settings} if available.
         */
        protected Double getE(BoaState state) {
                return state.getSettings().getParameters().getDouble("e", 1d, 0d, 1d);
        }

        /**
         * Overrideable for hard configuring this component.
         * 
         * @param state the {@link BoaState}
         * @return the parameter k for the time depemdency function
         *         {@link #f(double)}. The parameter is 0 by default, or the value
         *         for the "k" parameter in the {@link Settings} if available.
         */
        protected Double getK(BoaState state) {
                return state.getSettings().getParameters().getDouble("k", 0d, 0d, 1d);
        }

        /**
         * Overrideable for hard configuring this component.
         * 
         * @param state the {@link BoaState}
         * @return the min value for {@link #p(double)}. We use the "min" parameter
         *         in the {@link Settings} if available. If not available, the
         *         parameter is computed as the utility of the reservation bid. If
         *         there is no reservation bid, we use the minimum utility of the
         *         available profile.
         */
        protected Double getMin(BoaState state) {
                Double val = state.getSettings().getParameters().getDouble("min", null,
                                0d, 1d);
                if (val != null)
                        return val;
                // val=null, try the reservation bid
                LinearAdditive profile = (LinearAdditive) state.getProfile();
                if (profile.getReservationBid() != null) {
                        return profile.getUtility(profile.getReservationBid())
                                        .doubleValue();
                }

                return getBidspace(profile).getRange().getMin().doubleValue();
        }

        /**
         * Overrideable for hard configuring this component.
         * 
         * @param state the {@link BoaState}
         * @return the max value for {@link #p(double)}. We use the "max" parameter
         *         in the {@link Settings} if available. If not available, we use
         *         the maximum utility of the available profile.
         */
        protected Double getMax(BoaState state) {
                Double val = state.getSettings().getParameters().getDouble("max", null,
                                0d, 1d);
                if (val != null)
                        return val;
                UtilitySpace profile = (UtilitySpace) state.getProfile();
                return getBidspace(profile).getRange().getMax().doubleValue();

        }

        /**
         * factory method. Overridable for testing
         * 
         * @param profile the profile to get a bidspace for
         * @return {@link BidsWithUtility}
         */
        protected BidsWithUtility getBidspace(Profile profile) {
                return new BidsWithUtility((LinearAdditive) profile);
        }

        /**
         * Makes sure the target utility with in the acceptable range according to
         * the domain
         * 
         * @param t the normalized current time in the negotiation, where t=9 at
         *          start of negotiation and t=1 at end of negotiation.
         * @return double
         */
        private double p(double t) {
                return this.min + (this.max - this.min) * (1.0 - f(t));
        }

        /**
         * From the paper:
         * 
         * A wide range of time dependent functions can be defined by varying the
         * way in which f(t) is computed. However, functions must ensure that 0 <=
         * f(t) <= 1, f(0) = k, and f(1) = 1.
         * 
         * That is, the offer will always be between the value range, at the
         * beginning it will give the initial constant and when the deadline is
         * reached, it will offer the reservation value.
         * 
         * @param t the normalized current time in the negotiation, where t=9 at
         *          start of negotiation and t=1 at end of negotiation.
         * @return
         */
        private double f(double t) {
                return k + (1.0 - k) * Math.pow(t, 1.0 / e);
        }

}