source: opponentmodel/src/main/java/geniusweb/opponentmodel/bayesian/TriangleValueSetUtilities.java@ 52

package geniusweb.opponentmodel.bayesian;

import java.math.BigDecimal;
import java.math.RoundingMode;

import geniusweb.issuevalue.NumberValue;
import geniusweb.issuevalue.Value;
import geniusweb.profile.utilityspace.NumberValueSetUtilities;
import tudelft.utilities.immutablelist.Range;

/**
 * Similar to {@link NumberValueSetUtilities} but contains an extra mid point
 * between low and high value. Utilities are linearly interpolated within the
 * triangle and 0 outside. This is used by the {@link BayesianOpponentModel} and
 * not json-serializable.
 * <p>
 * DO NOT USE THIS. Private use for {@link BayesianOpponentModel}.
 */
class TriangleValueSetUtilities extends NumberValueSetUtilities {

        /**
         * The value and utility at mid point.
         */
        private final BigDecimal midValue;
        private final BigDecimal midUtility;

        /**
         * 
         * @param lowValue    the low value of the {@link Range}
         * @param lowUtility  the utility of the {@link #lowValue}. must be &ge; 0
         * @param midValue    the mid value of the {@link Range}. must be
         *                    &ge;lowValue and &le;highValue.
         * @param midUtility  the utility of the {@link #midValue}.
         * @param highValue   the high value of the {@link Range}. Must be @le;1
         * @param highUtility the utility of the {@link #highValue}
         */
        public TriangleValueSetUtilities(BigDecimal lowValue, BigDecimal lowUtility,
                        BigDecimal midValue, BigDecimal midUtility, BigDecimal highValue,
                        BigDecimal highUtility) {
                super(lowValue, lowUtility, highValue, highUtility);
                if (midValue == null || midUtility == null) {
                        throw new NullPointerException(
                                        "arguments midValue, midUtility must be non-null");
                }
                // ensure 0 <= lowvalue <=midvalue <= highvalue <=1
                if (midValue.compareTo(lowValue) < 0
                                || midValue.compareTo(highValue) > 0)
                        throw new IllegalArgumentException(
                                        "midvalue must be between lowValue and highValue");

                this.midValue = midValue;
                this.midUtility = midUtility;
        }

        /**
         * {@inheritDoc} <
         * <h2>Details</h2> Any value &ge; {@link #midValue} will be interpolated
         * from the mid-high interval; any value below the {@link #midValue} with
         * the low-mid interval. Any value outside low-high interval returns 0.
         * {@link #midUtility} is returned if value =midValue.
         */
        @Override
        public BigDecimal getUtility(Value value) {
                if (!(value instanceof NumberValue)) {
                        return BigDecimal.ZERO;
                }
                BigDecimal x = ((NumberValue) value).getValue();
                if (x.compareTo(getLowValue()) < 0 || x.compareTo(getHighValue()) > 0)
                        return BigDecimal.ZERO;

                BigDecimal lowValue, highValue, lowUtility, highUtility;

                if (x.compareTo(midValue) < 0) {
                        lowValue = getLowValue();
                        lowUtility = getLowUtility();
                        highValue = midValue;
                        highUtility = midUtility;
                } else {
                        lowValue = midValue;
                        lowUtility = midUtility;
                        highValue = getHighValue();
                        highUtility = getHighUtility();
                }
                if (x.compareTo(midValue) == 0)
                        return midUtility;

                // we need to be careful to avoid round errors from divides.
                // so we return lowU + deltaU * (x-lowV) /deltaV
                BigDecimal deltaU = highUtility.subtract(lowUtility);
                BigDecimal deltaV = highValue.subtract(lowValue);
                // deltaV can't be 0 because value!=midValue.

                return lowUtility.add(deltaU.multiply(
                                x.subtract(lowValue).divide(deltaV, 8, RoundingMode.HALF_UP)));
        }

        /**
         * 
         * @return the mid value
         */
        public BigDecimal getMidValue() {
                return midValue;
        }

        /**
         * 
         * @return the utility of the mid value.
         */
        public BigDecimal getMidUtility() {
                return midUtility;
        }

        @Override
        public String toString() {
                return "TriangleValueSetUtilities(" + getLowValue() + "->"
                                + getLowUtility() + "," + midValue + "->" + midUtility + ","
                                + getHighValue() + "->" + getHighUtility() + ")";
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = super.hashCode();
                result = prime * result
                                + ((midUtility == null) ? 0 : midUtility.hashCode());
                result = prime * result
                                + ((midValue == null) ? 0 : midValue.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (!super.equals(obj))
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                TriangleValueSetUtilities other = (TriangleValueSetUtilities) obj;
                if (midUtility == null) {
                        if (other.midUtility != null)
                                return false;
                } else if (!midUtility.equals(other.midUtility))
                        return false;
                if (midValue == null) {
                        if (other.midValue != null)
                                return false;
                } else if (!midValue.equals(other.midValue))
                        return false;
                return true;
        }

}