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

package agents.anac.y2019.authenticagent.serviceclasses;

import genius.core.Bid;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UtilityEstimationService implements Serializable {

    private static List<Issue> domainIssues;
    private static List<Map<String, Integer>> numberOfRepeatsForEachValueOfAnIssue = new ArrayList<>();
    private  static double numberOfPossibleBids;
    private static int numberOfIssues;
    private static double[] weightsForIssues;

    public static void init(List<Issue> listOfExistingIssues, double npb) {
        numberOfPossibleBids  = npb;
        domainIssues = listOfExistingIssues;
        numberOfIssues = listOfExistingIssues.size();
        weightsForIssues = new double[numberOfIssues];
        for (int i = 0; i < numberOfIssues; i++) {
            weightsForIssues[i] = 0;
        }
        for (int i = 0; i < numberOfIssues; i++) {
            IssueDiscrete discreteIssue = (IssueDiscrete) domainIssues.get(i);
            int numberOfValues = discreteIssue.getNumberOfValues();
            Map<String, Integer> repeatsForEachValue = new HashMap<>();
            String valueInString;
            for (int j = 0; j < numberOfValues; j++) {
                valueInString = discreteIssue.getValue(j).toString();
                repeatsForEachValue.put(valueInString, 0);
            }
            numberOfRepeatsForEachValueOfAnIssue.add(repeatsForEachValue);
        }
    }

    static void updateModel(Bid bid) {
        if (bid == null) return;
        for (int i = 0; i < domainIssues.size(); i++) {
            String key = bid.getValue(i + 1).toString();
            Integer currentValue = numberOfRepeatsForEachValueOfAnIssue.get(i).get(key);
            if(currentValue == null) {
                System.out.println("was null");
                currentValue = 0;
            } else
                currentValue++;
            numberOfRepeatsForEachValueOfAnIssue.get(i).put(key, currentValue);
            updateIssueWeight();
        }
    }

    public static double getEstimatedUtilityFor(Bid bid) {
//        if (numberOfPossibleBids == 0) {
//            return 0;
//        }
        double sumOfEachIssueUtility = 0;
        double sumOfIssueWeight = 0;
        for (double anIssueWeight : weightsForIssues) {
            sumOfIssueWeight += anIssueWeight;
        }
        for (int i = 1; i <= domainIssues.size(); i++) {
            String value = bid.getValue(i).toString();
            Integer numberOfPreOffers = numberOfRepeatsForEachValueOfAnIssue.get(i - 1).get(value);
            if(weightsForIssues[i - 1] != 0 && sumOfIssueWeight != 0)
                sumOfEachIssueUtility += ((double) numberOfPreOffers
                        / numberOfPossibleBids) * (weightsForIssues[i - 1] / sumOfIssueWeight);
            else
                sumOfEachIssueUtility += ((double) numberOfPreOffers
                        / numberOfPossibleBids) * (1 / (float)numberOfIssues);
        }
        return sumOfEachIssueUtility / numberOfIssues;
    }

    private  static void updateIssueWeight() {
        for (int i = 0; i < numberOfIssues; i++) {
            Map<String, Integer> issue = numberOfRepeatsForEachValueOfAnIssue.get(i);
            weightsForIssues[i] = calculateStandardDeviation(issue);
        }
    }

    private static double calculateStandardDeviation(Map<String, Integer> issue) {
        double sum = 0, mean;
        double standardDeviation;
        int size = issue.size();
        for (Object o : issue.entrySet()) {
            Map.Entry pair = (Map.Entry) o;
            sum += (Integer) pair.getValue();
        }
        mean = sum / size;
        double sum2 = 0;

        for (Object o : issue.entrySet()) {
            Map.Entry pair2 = (Map.Entry) o;
            sum2 += Math.pow((mean - (Integer) pair2.getValue()), 2);
        }
        if (sum2 != 0)
            standardDeviation = Math.sqrt(sum2 / size);
        else
            standardDeviation = 0;
        return standardDeviation;
    }
}