source: anac2020/Anaconda/src/main/java/geniusweb/exampleparties/anaconda/selfMap.java

package geniusweb.exampleparties.anaconda;

import java.math.BigInteger;
import java.util.*;

import geniusweb.bidspace.AllBidsList;
import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;
import geniusweb.issuevalue.ValueSet;
import geniusweb.profile.PartialOrdering;
import tudelft.utilities.immutablelist.Tuple;

@SuppressWarnings("serial")
public class selfMap extends HashMap<String, List<impUnit>> {
        private Domain domain;
        private HashMap<Bid, Double> bidsRank;
        private List<Tuple<Bid, Double>> sorted_bids;

        // importance map
        public selfMap(PartialOrdering profile) {
                super();
                this.domain = profile.getDomain();
                this.bidsRank = new HashMap<Bid, Double>();
                // Create empty my import map and opponent's value map
                for (String issue : domain.getIssues()) {
                        ValueSet values = domain.getValues(issue);
                        List<impUnit> issueImpUnit = new ArrayList<>();
                        for (Value value : values) {
                                issueImpUnit.add(new impUnit(value));
                        }
                        this.put(issue, issueImpUnit);
                }
        }

        public void comparison_update(Bid betterBid, Bid worseBid) {
                //update of freq table
                for (String issue : betterBid.getIssues()) {
                        List<impUnit> currentIssueList = this.get(issue);
                        for (impUnit currentUnit : currentIssueList) {
                                if (currentUnit.valueOfIssue.toString().equals(betterBid.getValue(issue).toString())) {
                                        //System.out.println(issue+":"+betterBid.getValue(issue).toString() + "&" + worseBid.getValue(issue).toString());
                                        //System.out.println(betterBid.getValue(issue).toString() != worseBid.getValue(issue).toString());
                                        if (!betterBid.getValue(issue).toString().equals(worseBid.getValue(issue).toString()))
                                        {
                                                currentUnit.victories++;
                                        }

                                        currentUnit.total_count++;
                                        break;
                                }
                        }
                }
                
                // Calculate weights
                for (List<impUnit> impUnitList : this.values()) {
                        for (impUnit currentUnit : impUnitList) {
                                //System.out.println(currentUnit.valueOfIssue.toString()+":"+String.valueOf(currentUnit.count) + ":" + 
                        //String.valueOf(currentUnit.weightSum) + ":" + String.valueOf(currentUnit.meanWeightSum));
                                if (currentUnit.total_count == 0) {
                                        currentUnit.probability = 0.0;
                                } else {
                                        currentUnit.probability = (double) currentUnit.victories
                                                        / (double) currentUnit.total_count;
                                }
                        }
                }
        }

        public void initial_update(List<Bid> bidOrdering, AllBidsList allBids) {
                for(int i = 0; i < bidOrdering.size(); i++) {
                        for(int j = i+1; j < bidOrdering.size(); j++) {
                                try {
                                        Bid worseBid = bidOrdering.get(i);
                                        Bid betterBid = bidOrdering.get(j);
                                        this.comparison_update(betterBid, worseBid);
                                } catch (Exception e) {
                                        throw e;
                                }
                        }
                }
                Bid minBid = bidOrdering.get(0);
                Bid maxBid = bidOrdering.get(bidOrdering.size() - 1);
                for (BigInteger i = BigInteger.ZERO; i.compareTo(allBids.size()) < 0; i=i.add(BigInteger.ONE)) {
                        Bid currentBid = allBids.get(i);
                        if (!bidOrdering.contains(currentBid)) {
                                this.comparison_update(currentBid, minBid);
                                this.comparison_update(maxBid, currentBid);
                        }
                }

                this.updateBidsRank(allBids);
        }
        
        public List<Bid> getBidsInRange(double lowerImportance, double higherImportance, AllBidsList allBids) {
                List<Bid> foundBids = new ArrayList<Bid>();

                for (Bid bid: allBids) {
                        double impOfBid = getImportance(bid); 
                        if (impOfBid >= lowerImportance && 
                                        impOfBid <= higherImportance) {
                                foundBids.add(bid);
                        }
                }
                return foundBids;
        }

        public Bid getBidForElicit(double lowerImportance, double higherImportance, AllBidsList allBids) {
                Map<String, Value> issuevalues = new HashMap<String, Value>();
                for (String issue : domain.getIssues()) {
                        ValueSet values = domain.getValues(issue);
                        int min_counter = Integer.MAX_VALUE;
                        for (Value value : values) {
                                for (impUnit i : this.get(issue)) {
                                        if (i.valueOfIssue.equals(value) && i.total_count < min_counter) {
                                                issuevalues.put(issue, value);
                                                break;
                                        }
                                }
                        }
                }
                Bid b = new Bid(issuevalues);
                return b;
        }
        
        
        public void updateBidsRank(AllBidsList allBids) {
                List<Tuple<Bid, Double>> bids_imp = new ArrayList();

                for (Bid bid: allBids) {
                        double imp = getImportance(bid);
                        this.bidsRank.put(bid, imp);
                        bids_imp.add(new Tuple(bid, imp));
                }

                bids_imp.sort(new bidImpComparator());
                this.sorted_bids = bids_imp;
        }

        public double getImportance(Bid bid) {
                double bidImportance = 0.0;
                for (String issue : bid.getIssues()) {
                        Value value = bid.getValue(issue);
                        double valueImportance = 0.0;
                        boolean flag = false;

                        for (impUnit i : this.get(issue)) {
                                if (i.valueOfIssue.equals(value)) {
                                        flag = true;
                                        valueImportance = i.probability;
                                        break;
                                }
                        }

                        bidImportance += Math.log(valueImportance);
                }
                return bidImportance;
        }

        public int importanceToRankAbs(double importance) {
                int rank = 0;

                for (Bid bid: this.bidsRank.keySet()) {
                        double impOfBid = this.bidsRank.get(bid);
                        if (impOfBid < importance) {
                                rank ++;
                        }
                }

                return rank;
        }

        public Bid getBestBid(List<Bid> bids) {
                Bid best_bid = null;
                double best_bid_imp = Double.NEGATIVE_INFINITY;

                for (Bid bid : bids) {
                        double bid_imp = this.bidsRank.get(bid);

                        if (bid_imp > best_bid_imp) {
                                best_bid_imp = bid_imp;
                                best_bid = bid;
                        }
                }

                return best_bid;
        }

        public double getMaxBidImp() {
                return rank_to_importance(this.sorted_bids.size() - 1);
        }

        public double rank_to_importance(int rank) {
                return this.sorted_bids.get(rank).get2();
        }

        public Bid getBidInRank(int bid_imp) {
                return this.sorted_bids.get(bid_imp).get1();
        }

        static class bidImpComparator implements Comparator<Tuple<Bid, Double>> {
                public int compare(Tuple<Bid, Double> o1, Tuple<Bid, Double> o2) {
                        return o1.get2().compareTo(o2.get2());
                }
        }
}