source: src/main/java/agents/anac/y2019/authenticagent/serviceclasses/SafeBidUtilityService.java@ 202

package agents.anac.y2019.authenticagent.serviceclasses;

import authenticagent.biddingstrategy.services.internalpackageservices.AgentTool;
import authenticagent.biddingstrategy.services.internalpackageservices.BidInfo;
import genius.core.Bid;
import genius.core.uncertainty.UserModel;
import genius.core.utility.UtilitySpace;

import java.util.*;

public class SafeBidUtilityService {

    private static UserModel userModel;
    private static UtilitySpace utilitySpace;
    private static List<BidInfo> bidInfoList;

    public static void init(UtilitySpace us, UserModel um){
        utilitySpace = us;
        userModel = um;
        double numberOfPossibleBids = userModel.getDomain().getNumberOfPossibleBids();
        UtilityEstimationService.init(utilitySpace.getDomain().getIssues(), numberOfPossibleBids);
        List<Bid> bids = userModel.getBidRanking().getBidOrder();
        for(Bid bid : bids)
            UtilityEstimationService.updateModel(bid);
        int seed = 810193570;
        bidInfoList = new ArrayList<>(AgentTool.generateRandomBids(userModel.getDomain(),
                50000, new Random(seed)));
        bidInfoList.sort((s1, s2) -> {
            Double u1, u2;
            u1 = UtilityEstimationService.getEstimatedUtilityFor(s1.getBid());
            u2 = UtilityEstimationService.getEstimatedUtilityFor(s2.getBid());
            return u1.compareTo(u2);
        });
    }

    public static Bid getBidWithUtility(double utility){
        return findBidWithUtility(0, bidInfoList.size() - 1, utility);
    }

    private static Bid findBidWithUtility(int lowerIndex, int higherIndex, double utility){
        int currentIndex;
        double currentUtility;
        Bid result;
        while (true) {
            if (lowerIndex == higherIndex)
                return bidInfoList.get(lowerIndex).getBid();
            currentIndex = (lowerIndex + higherIndex) >> 1;
            result = bidInfoList.get(currentIndex).getBid();
            currentUtility = UtilityEstimationService.getEstimatedUtilityFor(result);
            if (currentUtility == utility || Math.abs(currentUtility - utility) <= 0.001)
                return result;
            if (currentUtility > utility)
                lowerIndex = currentIndex;
            else
                higherIndex = currentIndex;
        }
    }

    public static Bid getBid(double threshold_high, double threshold_low) {
        return findBidWithUtility(0, bidInfoList.size() - 1, (threshold_high + threshold_low) / 2);
    }

    public static double getUtility(Bid bid){
        return UtilityEstimationService.getEstimatedUtilityFor(bid);
    }

    public static double getNumberOfPossibleBids(){
        if(userModel != null){
            return userModel.getDomain().getNumberOfPossibleBids();
        }
        if(utilitySpace != null)
            return utilitySpace.getDomain().getNumberOfPossibleBids();
        return 1001;
    }
}