source: src/main/java/agents/anac/y2015/JonnyBlack/Functions.java

package agents.anac.y2015.JonnyBlack;

import java.util.Vector;

import genius.core.Bid;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.ValueDiscrete;
import genius.core.utility.AdditiveUtilitySpace;

public class Functions {
        public static int[] calcOrderOfIssues(AdditiveUtilitySpace us) {
                int noOfIssues = us.getNrOfEvaluators();
                int[] issueOrder = new int[noOfIssues];
                for (int i = 0; i < issueOrder.length; i++) {
                        issueOrder[i] = i;
                }
                for (int i = 0; i < issueOrder.length; i++) {
                        for (int j = i + 1; j < issueOrder.length; j++) {
                                if (us.getWeight(issueOrder[i]) < us.getWeight(issueOrder[j])) {
                                        int temp = issueOrder[i];
                                        issueOrder[i] = issueOrder[j];
                                        issueOrder[j] = temp;
                                }
                        }
                }
                return issueOrder;
        }

        public static int[][] calcOrderOfIssueVals(AdditiveUtilitySpace us) {
                int noOfIssues = us.getNrOfEvaluators();
                int[][] orderOfVals = new int[noOfIssues][];
                for (int i = 0; i < noOfIssues; i++) {
                        int noVals = ((IssueDiscrete) (us.getIssue(i))).getNumberOfValues();
                        orderOfVals[i] = new int[noVals];
                }
                for (int i = 0; i < orderOfVals.length; i++) {
                        for (int j = 0; j < orderOfVals[i].length; j++) {
                                orderOfVals[i][j] = j + 1;
                        }
                }
                // TODO Not Ordering
                for (int i = 0; i < orderOfVals.length; i++) {
                        for (int j = 0; j < orderOfVals[i].length; j++) {
                                double value1 = getValueOfIssueVal(us, i, j);
                                for (int k = j; k < orderOfVals[i].length; k++) {
                                        double value2 = getValueOfIssueVal(us, i, k);
                                        if (value1 < value2) {
                                                int t = orderOfVals[i][j];
                                                orderOfVals[i][j] = orderOfVals[i][k];
                                                orderOfVals[i][k] = t;
                                        }
                                }
                        }
                }
                return orderOfVals;
        }

        public static double getValueOfIssueVal(AdditiveUtilitySpace us, int issue, int val) {
                Bid temp = getCopyOfBestBid(us);
                ValueDiscrete vd = getVal(us, issue, val);
                temp = temp.putValue(issue + 1, vd);
                double value = evaluateOneIssue(us, issue, temp);
                return value;
        }

        public static ValueDiscrete getVal(AdditiveUtilitySpace us, int issue, int valID) {
                IssueDiscrete is = (IssueDiscrete) us.getIssue(issue);
                return is.getValue(valID);
        }

        public static double evaluateOneIssue(AdditiveUtilitySpace us, int issue, Bid b) {
                try {
                        return us.getEvaluator(issue + 1).getEvaluation(us, b, issue + 1);
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return -1;
        }

        public static Bid getCopyOfBestBid(AdditiveUtilitySpace us) {
                try {
                        return new Bid(us.getMaxUtilityBid());
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return null;
        }

        public static double getBidValue(AdditiveUtilitySpace us, Bid b) {
                try {
                        return us.getUtility(b);
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                return -1;
        }

        public static double calcStopVal(Vector<Party> parties, int n,
                        AdditiveUtilitySpace us) {
                for (Party p : parties) {
                        p.orderBids(us);
                }
                Vector<BidHolder> topNbids = new Vector<BidHolder>();
                for (int i = 0; i < n && i < parties.get(0).orderedBids.size(); i++) {
                        topNbids.add(parties.get(0).orderedBids.get(i));
                }
                for (int i = 0; i < topNbids.size(); i++) {
                        for (Party p : parties) {
                                if (p.orderedBids.indexOf(topNbids.get(i)) > n
                                                || p.orderedBids.indexOf(topNbids.get(i)) == -1) {
                                        topNbids.remove(i);
                                        i--;
                                        break;
                                }
                        }
                }
                System.out.println("Common Bids : " + topNbids.size());
                double max = 0;
                for (BidHolder b : topNbids) {
                        double v = Functions.getBidValue(us, b.b);
                        if (v > max)
                                max = v;
                }
                return Math.max(max, 0.6);
        }
}