source: opponentmodel/src/main/java/geniusweb/opponentmodel/FrequencyOpponentModel.java@ 14

package geniusweb.opponentmodel;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.NumberValue;
import geniusweb.issuevalue.Value;
import geniusweb.profile.utilityspace.NumberValueSetUtilities;
import geniusweb.profile.utilityspace.UtilitySpace;

/**
 * implements an {@link OpponentModel} by counting frequencies of bids placed by
 * the opponent.
 * <p>
 * NOTE: {@link NumberValue}s are also treated as 'discrete', so the frequency
 * of one value does not influence the influence the frequency of nearby values
 * (as you might expect as {@link NumberValueSetUtilities} is only affected by
 * the endpoints).
 *
 */
public class FrequencyOpponentModel implements OpponentModel, UtilitySpace {

        private static final int DECIMALS = 4; // accuracy of our computations.
        private final Domain domain;
        private final Map<String, Map<Value, Integer>> bidFrequencies;
        private final BigDecimal totalBids;
        private static int serial = 1; // counter for auto name generation

        public FrequencyOpponentModel(Domain domain) {
                // map with empth hashmap for each issue.
                this(domain,
                                domain.getIssues().stream().collect(
                                                Collectors.toMap(iss -> iss, iss -> new HashMap<>())),
                                BigDecimal.ZERO);
        }

        @Override
        public BigDecimal getUtility(Bid bid) {
                String err = domain.isComplete(bid);
                if (err != null) {
                        throw new IllegalArgumentException(err);
                }
                if (totalBids == BigDecimal.ZERO) {
                        return BigDecimal.ONE;
                }
                BigDecimal sum = BigDecimal.ZERO;
                // Assume all issues have equal weight.
                for (String issue : domain.getIssues()) {
                        sum = sum.add(getFraction(issue, bid.getValue(issue)));
                }
                return sum.divide(new BigDecimal(bidFrequencies.size()), DECIMALS,
                                BigDecimal.ROUND_HALF_UP);
        }

        @Override
        public String getName() {
                return "FreqOppModel" + (serial++) + "For" + domain;
        }

        /**
         * 
         * @param issue the issue to check
         * @param value the value to check
         * @return the fraction of the total cases that bids contained given value
         *         for the issue.
         */
        private BigDecimal getFraction(String issue, Value value) {
                if (totalBids == BigDecimal.ZERO) {
                        return BigDecimal.ONE;
                }
                Integer freq = bidFrequencies.get(issue).get(value);
                if (freq == null) {
                        freq = 0;
                }
                return new BigDecimal(freq).divide(totalBids, DECIMALS,
                                BigDecimal.ROUND_HALF_UP);
        }

        @Override
        public Domain getDomain() {
                return domain;
        }

        @Override
        public FrequencyOpponentModel update(Bid bid) {
                String err = domain.isComplete(bid);
                if (err != null) {
                        throw new IllegalArgumentException(err);
                }
                Map<String, Map<Value, Integer>> newFreqs = cloneMap(bidFrequencies);
                for (String issue : domain.getIssues()) {
                        Map<Value, Integer> freqs = newFreqs.get(issue);
                        Value value = bid.getValue(issue);
                        Integer oldfreq = freqs.get(value);
                        if (oldfreq == null) {
                                oldfreq = 0;
                        }
                        freqs.put(value, oldfreq + 1);
                }

                return new FrequencyOpponentModel(domain, newFreqs,
                                totalBids.add(BigDecimal.ONE));
        }

        /**
         * internal constructor. Assumes the freqs keyset is equal to the available
         * issues.
         * 
         * @param domain the domain
         * @param freqs  the observed frequencies for all issue values. This map is
         *               assumed to be a fresh private-access only copy.
         * @param total  the total number of bids contained in the freqs map. This
         *               must be equal to the sum of the Integer values in the
         *               {@link #bidFrequencies} for each issue (this is not
         *               checked).
         */
        private FrequencyOpponentModel(Domain domain,
                        Map<String, Map<Value, Integer>> freqs, BigDecimal total) {
                if (domain == null) {
                        throw new NullPointerException("domain=null");
                }
                this.domain = domain;
                this.bidFrequencies = freqs;
                this.totalBids = total;
        }

        /**
         * 
         * @param freqs
         * @return deep copy of freqs map.
         */
        private static Map<String, Map<Value, Integer>> cloneMap(
                        Map<String, Map<Value, Integer>> freqs) {
                Map<String, Map<Value, Integer>> map = new HashMap<>();
                for (String issue : freqs.keySet()) {
                        map.put(issue, new HashMap<Value, Integer>(freqs.get(issue)));
                }
                return map;
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result
                                + ((bidFrequencies == null) ? 0 : bidFrequencies.hashCode());
                result = prime * result + ((domain == null) ? 0 : domain.hashCode());
                result = prime * result
                                + ((totalBids == null) ? 0 : totalBids.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                FrequencyOpponentModel other = (FrequencyOpponentModel) obj;
                if (bidFrequencies == null) {
                        if (other.bidFrequencies != null)
                                return false;
                } else if (!bidFrequencies.equals(other.bidFrequencies))
                        return false;
                if (domain == null) {
                        if (other.domain != null)
                                return false;
                } else if (!domain.equals(other.domain))
                        return false;
                if (totalBids == null) {
                        if (other.totalBids != null)
                                return false;
                } else if (!totalBids.equals(other.totalBids))
                        return false;
                return true;
        }

        @Override
        public String toString() {
                return "FrequencyOpponentModel[" + totalBids + "," + bidFrequencies
                                + "]";
        }

        @Override
        public Bid getReservationBid() {
                throw new UnsupportedOperationException();
        }

}