source: domaineditor/src/main/java/geniusweb/domaineditor/model/profile/LinearAdditiveUtilitySpaceModel.java@ 52

package geniusweb.domaineditor.model.profile;

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

import geniusweb.domaineditor.model.BidModel;
import geniusweb.domaineditor.model.DiscreteValueSetModel;
import geniusweb.domaineditor.model.DomainModel;
import geniusweb.domaineditor.model.NumberValueSetModel;
import geniusweb.domaineditor.model.SimpleStringModel;
import geniusweb.domaineditor.model.ValueSetModel;
import geniusweb.profile.utilityspace.LinearAdditiveUtilitySpace;
import geniusweb.profile.utilityspace.ValueSetUtilities;
import tudelft.utilities.listener.DefaultListenable;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.mvc.model.ListModel;
import tudelft.utilities.mvc.model.MapFromKeys;
import tudelft.utilities.mvc.model.MapModel;
import tudelft.utilities.mvc.model.NumberModel;
import tudelft.utilities.mvc.model.RestrictedNumberModel;
import tudelft.utilities.mvc.model.StringModel;
import tudelft.utilities.mvc.model.TypedModel;
import tudelft.utilities.mvc.model.events.Event;
import tudelft.utilities.mvc.panels.PopupReporter;

/**
 * Model containing a {@link LinearAdditiveUtilitySpace}
 */
public class LinearAdditiveUtilitySpaceModel extends DefaultListenable<Event>
                implements ProfileModel, TypedModel<LinearAdditiveUtilitySpace> {
        private final SimpleStringModel name;
        /**
         * the key is the issue, the value is the valuesetutilities for this issue.
         * Should be immutable so do not return direct access to this field.
         */
        private final MapModel<StringModel, ValueSetUtilitiesModel> issueUtilities;

        /**
         * The key is the issue, the value is the weight of the utilities for that
         * issue (utility as returned from the ValueSetUtilities for that issue).
         */
        private final MapModel<StringModel, RestrictedNumberModel> issueWeights;

        private final DomainModel domain;

        private final BidModel reservationBid;
        private Reporter log;

        /**
         * @param name           the name for the profile.
         * @param issueUtilities a map of issue-values. Issues are
         *                       {@link StringModel}.
         * @param weights        the issue weights. RestrictedNumberModel with
         *                       minimum 0 and max 1. The set of keys (issue
         *                       {@link StringModel}) must equal the issueUtilities
         *                       keyMap
         * @param domain         the {@link DomainModel}. Issues in the domain must
         *                       equal to issueUtities keys.
         * @param reservationBid the {#link BidModel} holding the reservation bid
         * @param log            the {@link Reporter}
         */
        public LinearAdditiveUtilitySpaceModel(SimpleStringModel name,
                        MapModel<StringModel, ValueSetUtilitiesModel> issueUtilities,
                        MapModel<StringModel, RestrictedNumberModel> weights,
                        DomainModel domain, BidModel reservationBid, Reporter log) {
                if (!domain.getIssues().getKeys().equals(issueUtilities.getKeys()))
                        throw new IllegalArgumentException(
                                        "issues in domain and isseuUtilities are not equal");
                if (!domain.getIssues().getKeys().equals(weights.getKeys()))
                        throw new IllegalArgumentException(
                                        "issues in domain and weight map are not equal");
                this.name = name;
                this.issueUtilities = issueUtilities;
                this.issueWeights = weights;
                this.domain = domain;
                this.reservationBid = reservationBid;
                this.log = log;
        }

        protected static final BigDecimal N05 = new BigDecimal("0.5");
        // dummylog is for events that should never happen.
        private static Reporter dummylog = new PopupReporter(null);
        // we should never allow editing of these constants.
        protected static final NumberModel CONSTANT0 = new NumberModel(
                        BigDecimal.ZERO, dummylog);
        protected static final NumberModel CONSTANT1 = new NumberModel(
                        BigDecimal.ONE, dummylog);

        public LinearAdditiveUtilitySpaceModel(DomainModel domain,
                        final Reporter log) {
                this(new SimpleStringModel("profilename", log),
                                createUtilsMap(domain, log), createWeightMap(domain, log),
                                domain, new BidModel(domain.getIssues(), log), log);
        }

        /**
         * creates a initial weight map for domain
         * 
         * @param domain2
         * @return MapModel with issue-weight pairs. Map keys are issues from the
         *         domain.
         */
        private static MapModel<StringModel, RestrictedNumberModel> createWeightMap(
                        final DomainModel domain2, final Reporter log) {
                return new MapFromKeys<StringModel, RestrictedNumberModel>(
                                domain2.getIssues().getKeys(), log, true) {

                        @Override
                        public RestrictedNumberModel create(StringModel key) {
                                return new RestrictedNumberModel(N05, CONSTANT0, CONSTANT1,
                                                log);
                        }

                        @Override
                        public String getColumnName(int n) {
                                return n == 0 ? "issue" : "weight";
                        }

                };
        }

        private static MapModel<StringModel, ValueSetUtilitiesModel> createUtilsMap(
                        final DomainModel domain2, final Reporter log) {
                // do not retain old values, issues may be removed and replaced with
                // different type
                return new MapFromKeys<StringModel, ValueSetUtilitiesModel>(
                                domain2.getIssues().getKeys(), log, false) {
                        @Override
                        public ValueSetUtilitiesModel create(StringModel key) {
                                ValueSetModel val = domain2.getIssues().getValue(key);
                                if (val instanceof DiscreteValueSetModel)
                                        return new DiscreteValueSetUtilitiesModel(
                                                        (DiscreteValueSetModel) val, log);
                                if (val instanceof NumberValueSetModel)
                                        return new NumberValueSetUtilitiesModel(
                                                        (NumberValueSetModel) val, log);
                                throw new RuntimeException(
                                                "Unsupported type " + val + "for key" + key);
                        }

                        @Override
                        public String getColumnName(int n) {
                                return n == 0 ? "value" : "utility";
                        }

                };
        }

        /**
         * 
         * @return the {@link DomainModel}
         */
        public DomainModel getDomain() {
                return domain;
        }

        /**
         * 
         * @return {@link StringModel} containing the domain name
         */
        public StringModel getName() {
                return name;
        }

        /**
         * 
         * @return {@link BidModel} containing the reservation bid
         */
        public BidModel getReservationBid() {
                return reservationBid;
        }

        /**
         * @return the weights map, but all weights are NOT NORMALIZED.
         */
        public MapModel<StringModel, RestrictedNumberModel> getWeights() {
                return issueWeights;
        }

        /**
         * 
         * @return the issue utilities map
         */
        public MapModel<StringModel, ValueSetUtilitiesModel> getIssueUtilities() {
                return issueUtilities;
        }

        @Override
        public LinearAdditiveUtilitySpace getCurrentValue()
                        throws IllegalStateException {
                return new LinearAdditiveUtilitySpace(domain.getCurrentValue(),
                                name.getValue(), getUtilitiesMap(), getNormalizedWeightMap(),
                                reservationBid.getCurrentValue());
        }

        /**
         * 
         * @return a Utilities map as contained in the current settings
         */
        private Map<String, ValueSetUtilities> getUtilitiesMap() {
                Map<String, ValueSetUtilities> map = new HashMap<>();
                for (int n = 0; n < issueUtilities.getKeys().getSize(); n++) {
                        StringModel issuem = issueUtilities.getKeys().get(n);
                        map.put(issuem.getValue(),
                                        issueUtilities.getValue(issuem).getCurrentValue());
                }
                return map;
        }

        @Override
        public void setCurrentValue(LinearAdditiveUtilitySpace obj)
                        throws IllegalArgumentException {
                LinearAdditiveUtilitySpace space = obj;
                name.setValue(space.getName());
                domain.setCurrentValue(space.getDomain());
                reservationBid.setCurrentValue(space.getReservationBid());

                ListModel<StringModel> issuesm = domain.getIssues().getKeys();
                for (int n = 0; n < issuesm.getSize(); n++) {
                        StringModel issuem = issuesm.get(n);
                        String issue = issuem.getValue();
                        issueWeights.getValue(issuem).setValue(space.getWeight(issue));
                        issueUtilities.getValue(issuem)
                                        .setCurrentValue(space.getUtilities().get(issue));
                }

        }

        /**
         * 
         * @return normalized weight map
         */
        protected Map<String, BigDecimal> getNormalizedWeightMap() {
                Map<String, BigDecimal> weights = new HashMap<>();
                for (int n = 0; n < issueWeights.getKeys().getSize(); n++) {
                        StringModel key = issueWeights.getKeys().get(n);
                        weights.put(key.getValue(), issueWeights.getValue(key).getValue());
                }

                BigDecimal sum = weights.values().stream().reduce(BigDecimal.ZERO,
                                BigDecimal::add);
                // weights1 may still contain rounding errors
                Map<String, BigDecimal> normap = weights.entrySet().stream()
                                .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()
                                                .divide(sum, 6, RoundingMode.HALF_UP)));
                BigDecimal err = normap.values().stream()
                                .reduce(BigDecimal.ZERO, BigDecimal::add)
                                .subtract(BigDecimal.ONE);
                // just subtract err from the biggest value
                String maxkey = Collections
                                .max(normap.entrySet(), Map.Entry.comparingByValue()).getKey();
                normap.put(maxkey, normap.get(maxkey).subtract(err));
                return normap;
        }

}