source: src/main/java/agents/anac/y2014/Aster/GetAcceptProb.java@ 316

package agents.anac.y2014.Aster;

import java.util.ArrayList;

import genius.core.Bid;
import genius.core.utility.AbstractUtilitySpace;

public class GetAcceptProb {
        private AbstractUtilitySpace utilitySpace;
        private double target;
        private double bidTarget;
        private double sum;
        private double sum2;
        private double prob;
        private double deviation;
        private double estimateMax;
        private int rounds;
        private double tremor;
        private double minimumConcessionUtility;
        private double minimum;
        private double maximumConcessionUtility;
        private double maximum;
        private double alpha;
        private double diff;
        private double alphaInit;
        private double estrangement;
        private boolean firstFlag;
        private ArrayList<Double> oppUtilHistory;
        private ArrayList<Double> oppShort_EMA;
        private ArrayList<Double> oppLong_EMA;
        private static final int EMA_SHORT = 26;
        private static final int EMA_LONG = 52;

        public GetAcceptProb(AbstractUtilitySpace utilitySpace) {
                this.utilitySpace = utilitySpace;
                this.target = 1.0D;
                this.bidTarget = 1.0D;
                this.sum = 0.0D;
                this.sum2 = 0.0D;
                this.prob = 0.0D;
                this.rounds = 0;
                this.tremor = 3.0D;
                this.minimumConcessionUtility = 0.1D;
                this.maximumConcessionUtility = 1.0D;
                this.maximum = 1.0D;
                this.deviation = 0.0D;
                this.estimateMax = 0.0D;
                this.alphaInit = 1.0D;
                this.estrangement = 1.0D;
                this.firstFlag = false;
                this.oppUtilHistory = new ArrayList<Double>();
                this.oppShort_EMA = new ArrayList<Double>();
                this.oppLong_EMA = new ArrayList<Double>();
                this.checkDiscountFactor();
        }

        /**
         * Calculate Accept Probability
         *
         */
        public double getAcceptProbability(Bid offeredBid, double oppMaxUtil,
                        double time) throws Exception {
                double unDiscountedOfferedUtil = utilitySpace.getUtility(offeredBid);
                double offeredUtility = utilitySpace.getUtilityWithDiscount(offeredBid,
                                time);
                double weight, mean, variance, rand, alpha, beta, preTarget, preTarget2, ratio, ratio2;
                double utilityEval, satisfy;

                checkException(offeredUtility, time); // checkException

                if (offeredUtility > 1.0D) {
                        offeredUtility = 1.0D;
                }

                // Historyã�«è¿½åŠ 
                oppUtilHistory.add(unDiscountedOfferedUtil);

                if (oppUtilHistory.size() > EMA_SHORT) {
                        double emaUtility;
                        if (oppShort_EMA.isEmpty()) {
                                oppShort_EMA.add(calcN_EMA_init(oppUtilHistory, EMA_SHORT));
                        } else {
                                emaUtility = oppShort_EMA.get(oppShort_EMA.size() - 1);
                                oppShort_EMA.add(calcN_EMA(emaUtility, unDiscountedOfferedUtil,
                                                EMA_SHORT));
                        }
                        if (oppUtilHistory.size() > EMA_LONG) {
                                if (oppLong_EMA.isEmpty()) {
                                        oppLong_EMA.add(calcN_EMA_init(oppUtilHistory, EMA_LONG));
                                } else {
                                        emaUtility = oppLong_EMA.get(oppLong_EMA.size() - 1);
                                        oppLong_EMA.add(calcN_EMA(emaUtility,
                                                        unDiscountedOfferedUtil, EMA_LONG));
                                        estrangement = calcEMAEstrangement();
                                }
                        }
                }

                // ��付�
                if ((this.estimateMax != 0.0) && (offeredUtility > this.estimateMax)) {
                        weight = offeredUtility / estimateMax;
                        offeredUtility *= weight;
                } else {
                        weight = 1.0;
                }

                // �計値
                sum += offeredUtility;
                // 効用値�二乗��計
                sum2 += offeredUtility * offeredUtility;
                // ラウンド数
                rounds += weight;

                // ï¼ˆåŠ é‡�）平å�‡å€¤
                mean = sum / rounds;

                // 分散
                variance = sum2 / rounds - mean * mean;
                // 相手�推定行動幅
                deviation = Math.sqrt(variance * 12.0D);

                if (Double.isNaN(deviation)) {
                        deviation = 0.0;
                }

                // �在推定�れる�相手�ら引�出�る最大効用値
                estimateMax = mean + (1.0D - mean) * deviation;
                double diffest = oppMaxUtil - estimateMax;
                if (diffest > 0) {
                        estimateMax *= 1.0D + diffest;
                }

                if (firstFlag) {
                        estimateMax = .990 * estrangement;
                }

                // 接近関数
                alpha = alphaInit + tremor + (10.0D * mean) - (2.0D * tremor * mean);
                rand = minimum + (maximum - minimum) * Math.random();
                beta = alpha + rand * tremor - tremor / 2.0D;

                // 接近関数を基�計算
                preTarget = calcPreTarget(alpha, time);
                preTarget2 = calcPreTarget(beta, time);

                // 相手��譲歩比率
                ratio = calcRatio(preTarget);
                ratio2 = calcRatio(preTarget2);

                // 補正
                target = calcTarget(ratio, preTarget, time, oppMaxUtil, false);
                bidTarget = calcTarget(ratio2, preTarget2, time, oppMaxUtil, true)
                                * estrangement;
                if (bidTarget > 1.0D) {
                        bidTarget = 0.99D;
                }

                utilityEval = offeredUtility - oppMaxUtil;
                satisfy = offeredUtility - target;
                prob = Math.pow(time, alpha) / alpha + utilityEval + satisfy;

                if ((prob < 0.1D) || (Double.isNaN(prob))) {
                        prob = 0.0D;
                }

                return prob;
        }

        /**
         * getCurrentBidTarget
         *
         */
        public double getCurrentBidTarget() {
                return this.bidTarget;
        }

        public double getEstimateMax() {
                return this.estimateMax;
        }

        /**
         * �回設定
         * 
         * @param sessionNr
         * @param maxConcessionUtility
         * @param opponentMinUtility
         */
        public void setTargetParam(int sessionNr, double maxConcessionUtility,
                        double opponentMinUtility) {
                // �回�強気
                if (sessionNr == 0) {
                        this.firstFlag = true;
                        this.alpha = 15;
                        this.diff = 1.0;
                } else {
                        this.alpha = 15;
                        this.diff = 0.5 * (0.5 + utilitySpace.getDiscountFactor());
                        this.maximumConcessionUtility = 1.0D;
                        this.minimumConcessionUtility = opponentMinUtility;
                }
        }

        public void updateMinConcessionUtil(double minConcessionUtil) {
                this.minimumConcessionUtility = minConcessionUtil;
        }

        private double calcPreTarget(double x, double t) {
                return 1.0D - Math.pow(t, x) * (1.0D - this.estimateMax);
        }

        private double calcRatio(double preTarget) {
                double preRatio = (this.deviation + this.minimumConcessionUtility)
                                / (1.0D - preTarget);

                if ((Double.isNaN(preRatio)) || (preRatio > 2.0D)) {
                        return 2.0D;
                } else {
                        return preRatio;
                }
        }

        private double calcTarget(double ratio, double preTarget, double t,
                        double oppMax, boolean checkdf) {
                double target = (ratio * preTarget + maximumConcessionUtility - ratio);
                double pt;
                if ((checkdf) && (utilitySpace.getDiscountFactor() < 1.0)) {
                        pt = 1.0 / (1.0 + Math.exp(-alpha * (t - diff)));
                } else {
                        pt = Math.pow(t, 3);
                }
                double m = pt * -300.0D + 400.0D;
                if (target > this.estimateMax) {
                        double r = target - this.estimateMax;
                        double f = 1.0D / (r * r);
                        double app;

                        if ((f > m) || (Double.isNaN(f))) {
                                f = m;
                        }
                        app = r * f / m;
                        target -= app;
                } else {
                        target = this.estimateMax;
                }

                if (Double.isNaN(target)) {
                        target = 1.0D;
                }

                target = checkReservationValue(target, t);

                return target;
        }

        // EMA�計算（�回）
        private double calcN_EMA_init(ArrayList<Double> oppUtilHist, int n) {
                double ave = 0.0D;
                for (int i = 0; i < n; i++) {
                        ave += oppUtilHist.get(i);
                }
                return ave / n;
        }

        // EMA�計算
        private double calcN_EMA(double prevutil, double util, int n) {
                return prevutil + (2.0D / (1.0D + (double) n)) * (util - prevutil);
        }

        // EMA2線カイリ率
        private double calcEMAEstrangement() {
                int size = oppLong_EMA.size() - 1;
                double emaShort = oppShort_EMA.get(size + EMA_SHORT);
                double emaLong = oppLong_EMA.get(size);
                double estrangement = 1.0 + ((emaShort - emaLong) / emaLong);
                if (estrangement > 1.0) {
                        estrangement = 1.0;
                }
                return estrangement;
        }

        private double checkReservationValue(double target, double t) {
                double reservationValue = utilitySpace
                                .getReservationValueWithDiscount(t);

                if (!Double.isNaN(reservationValue)) {
                        if (target < reservationValue) {
                                return reservationValue;
                        }
                }
                return target;
        }

        private void checkException(double oUtility, double t) throws Exception {
                if ((oUtility < 0.0D) || (oUtility > 1.05D)) {
                        throw new Exception("utility " + oUtility + " outside [0,1]");
                }
                if ((t < 0.0D) || (t > 1.0D)) {
                        throw new Exception("time " + t + " outside [0,1]");
                }
        }

        private void checkDiscountFactor() {
                double discountfactor = utilitySpace.getDiscountFactor();

                if (discountfactor < 1.0) {
                        this.minimum = 0.5;
                } else {
                        this.minimum = 0.7;
                }
        }
}