source: src/main/java/bargainingchips/analysis/BundleUtilityPoint.java@ 339

package bargainingchips.analysis;

import java.io.Serializable;
import java.util.Arrays;

import bargainingchips.Bundle;

/**
 * This class adapts {@link genius.core.analysis.BidPoint}. 
 * A BundlePoint is a tuple which contains the utility of a particular bundle for each
 * agent.
 * 
 */
public class BundleUtilityPoint implements Serializable {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;
        /**
         * 
         */
        /** Bundle of which the utilities are shown. */
        private Bundle bundle;
        /** Array holding the utility of the bundle for each agent. */
        private Double[] utility;

        /**
         * Create a BundlePoint by given the bundle and the tuple of utilities for that
         * bundle.
         * 
         * @param bundle
         *            from which the utilities are stored.
         * @param utility
         *            tuple of utilities of the bundle.
         */
        public BundleUtilityPoint(Bundle bundle, Double... utility) {
                this.bundle = bundle;
                this.utility = utility.clone();
        }

        /**
         * @return string representation of the object.
         */
        @Override
        public String toString() {
                String result = "BundlePoint [" + bundle + ",";
                for (int i = 0; i < utility.length; i++) {
                        result += "util" + i + "[" + utility[i] + "],";
                }
                return result;
        }

        /**
         * @param obj
         *            object to which this object is compared.
         * @return true if this object is equal to the given object.
         */
        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                BundleUtilityPoint other = (BundleUtilityPoint) obj;
                if (bundle == null) {
                        if (other.bundle != null)
                                return false;
                } else if (!bundle.equals(other.bundle))
                        return false;
                if (this.utility.length != other.utility.length) {
                        return false;
                }

                for (int i = 0; i < this.utility.length; i++) {
                        if (!this.utility[i].equals(other.utility[i])) {
                                return false;
                        }
                }
                return true;
        }

        /**
         * @return hashcode of this object.
         */
        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((bundle == null) ? 0 : bundle.hashCode());
                result = prime * result + Arrays.hashCode(utility);
                return result;
        }

        /**
         * Bundle from which the utilities are represented. This bundle may be null to
         * save memory.
         * 
         * @return bundle which utilities are represented.
         */
        public Bundle getBundle() {
                return bundle;
        }

        /**
         * Returns the utility of the bundle for the i'th agent (agent A = 0, etc.).
         * 
         * @param index
         *            of the agent of which the utility should be returned.
         * @return utility of the bundle for the i'th agent.
         */
        public Double getUtility(int index) {
                return utility[index];
        }

        /**
         * Returns the utility of the bundle for agent A.
         * 
         * @return utility for agent A.
         */
        public Double getUtilityA() {
                return utility[0];
        }

        /**
         * Returns the utility of the bundle for agent B.
         * 
         * @return utility for agent B.
         */
        public Double getUtilityB() {
                return utility[1];
        }

        /**
         * Returns true if this BundlePoint is strictly dominated by another BundlePoint.
         * A BundlePoint is dominated when the utility of the other bundle for at least
         * one agent is higher and equal for the other agent.
         * 
         * @param other
         *            BundlePoint.
         * @return true if "other" dominates "this".
         */
        public boolean isStrictlyDominatedBy(BundleUtilityPoint other) {
                if (this == other) {
                        return false;
                }

                boolean atleastOneBetter = false;

                for (int i = 0; i < utility.length; i++) {
                        if (other.utility[i] >= this.utility[i]) {
                                if (other.utility[i] > this.utility[i]) {
                                        atleastOneBetter = true;
                                }
                        } else {
                                return false;
                        }
                }
                return atleastOneBetter;
        }

        /**
         * Returns the distance between this BundlePoint and another BundlePoint. sqrt((Tx
         * - Ox) ^ 2 + (Ty - Oy) ^ 2 + ...).
         * 
         * @param other
         *            bundlepoint to which the distance is calculated.
         * @return distance to the given bundlepoint.
         */
        public double getDistance(BundleUtilityPoint other) {
                double sum = 0;
                for (int i = 0; i < utility.length; i++) {
                        sum += Math.pow(this.utility[i] - other.utility[i], 2);
                }
                return Math.sqrt(sum);
        }

        /**
         * 
         * @return sum of utilities of all parties for this bundle
         */
        public double getSocialWelfare() {
                double sum = 0;
                for (double util : utility) {
                        sum += util;
                }
                return sum;
        }
}