source: java2python/geniuswebtranslator/geniuswebsrc/geniusweb/bidspace/pareto/ParetoPoint.java@ 869

package geniusweb.bidspace.pareto;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.jdt.annotation.NonNull;

import geniusweb.issuevalue.Bid;
import geniusweb.profile.utilityspace.LinearAdditive;

/**
 * A Paretopoint is a Bid together with an N-dimensional utility vector. This is
 * also a caching mechanism to avoid repeated utility computation of good bids.
 * This is a internal utility class to streamline pareto computations.
 */
class ParetoPoint {

        private final @NonNull Bid bid;
        // ArrayList is faster in indexing which is main reason for this class
        private final @NonNull ArrayList<@NonNull BigDecimal> utilities = new ArrayList<>();

        /**
         * 
         * @param bid    a (possibly partial) {@link Bid}
         * @param spaces the {@link LinearAdditive}s to consider
         */
        public ParetoPoint(final @NonNull Bid bid,
                        final @NonNull List<@NonNull LinearAdditive> spaces) {
                if (bid == null)
                        throw new NullPointerException("bid must be not null");
                if (spaces == null || spaces.contains(null))
                        throw new NullPointerException("utils must not contain null");
                this.bid = bid;

                for (final @NonNull LinearAdditive space : spaces) {
                        utilities.add(space.getUtility(bid));
                }
        }

        private ParetoPoint(final @NonNull List<@NonNull BigDecimal> utils,
                        final @NonNull Bid bid) {
                if (bid == null)
                        throw new NullPointerException("bid must be not null");
                if (utils == null || utils.contains(null))
                        throw new NullPointerException("utils must not contain null");
                this.bid = bid;
                this.utilities.addAll(utils);
        }

        @NonNull
        /**
         * Merges the issues from both bids and adds the utilities. This only works
         * correctly if the issues in other point are completely disjoint from our
         * bid issues.
         * 
         * @param otherpoint with the utils summed and the issue values merged
         */
        public ParetoPoint merge(@NonNull ParetoPoint otherpoint) {
                final @NonNull List<@NonNull BigDecimal> summedutils = new LinkedList<>();
                for (int n = 0; n < utilities.size(); n = n + 1) {
                        summedutils.add(utilities.get(n).add(otherpoint.utilities.get(n)));
                }

                return new ParetoPoint(summedutils, bid.merge(otherpoint.getBid()));
        }

        /**
         * 
         * @param other
         * @return true if this ParetoPoint is dominated by the other. That means
         *         other has better or equal utilities in ALL dimensions.
         */
        public boolean isDominatedBy(@NonNull ParetoPoint other) {
                final @NonNull List<@NonNull BigDecimal> otherutils = other
                                .getUtilities();
                for (int i = 0; i < utilities.size(); i = i + 1) {
                        if (otherutils.get(i).compareTo(utilities.get(i)) < 0) {
                                return false;
                        }
                }
                return true;
        }

        protected @NonNull List<@NonNull BigDecimal> getUtilities() {
                return utilities;
        }

        public @NonNull Bid getBid() {
                return bid;
        }

}