source: java2python/geniuswebtranslator/geniuswebsrc/geniusweb/bidspace/Interval.java@ 830

package geniusweb.bidspace;

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

import org.eclipse.jdt.annotation.NonNull;

/**
 * An interval [min, max].
 *
 */
public class Interval {
        public static @NonNull Interval ZERO = new Interval(BigDecimal.ZERO,
                        BigDecimal.ZERO);
        public static @NonNull Interval EMPTY = new Interval(BigDecimal.ONE,
                        BigDecimal.ZERO);

        private final @NonNull BigDecimal min;
        private final @NonNull BigDecimal max;

        /**
         * AN interval [min,max]. If min > max, then there are no values in this
         * interval.
         * 
         * @param min the minimum value of the interval (inclusive)
         * @param max the maximum value of the interval (inclusive)
         */
        public Interval(@NonNull BigDecimal min, @NonNull BigDecimal max) {
                if (min == null || max == null) {
                        throw new NullPointerException("min and max must contain not null");
                }
                this.min = min;
                this.max = max;
        }

        @NonNull
        /**
         * 
         * @return the minimum value of the interval
         */
        public BigDecimal getMin() {
                return min;
        }

        @NonNull
        /**
         * 
         * @return the maximum value of the interval
         */
        public BigDecimal getMax() {
                return max;
        }

        /**
         * 
         * @return true iff this range does not contain any element.
         */
        public boolean isEmpty() {
                return min.compareTo(max) > 0;
        }

        /**
         * 
         * @param value the value to test
         * @return true iff min ≤ value ≤ max
         */
        public boolean contains(@NonNull BigDecimal value) {
                return min.compareTo(value) <= 0 && max.compareTo(value) >= 0;
        }

        @NonNull
        /**
         * 
         * @param other {@link Interval} to be added to this
         * @return new interval [ this.min + other.min , this.max + other.max ]
         */
        public Interval add(@NonNull Interval other) {
                return new Interval(min.add(other.min), max.add(other.max));
        }

        @NonNull
        /**
         * 
         * @param other another {@link Interval} intersect with
         * @return intersection of this with other. returns null if intersection is
         *         empty.
         */
        public Interval intersect(@NonNull Interval other) {
                return new Interval(min.max(other.min), max.min(other.max));
        }

        @NonNull
        /**
         * 
         * @param other the other minmax to deal with
         * @return the range of values that, when added to a value from other, will
         *         possibly get in our range. effectively, [min-other.max,
         *         max-other.min]. Returns {@link #EMPTY} if the resulting range is
         *         empty.
         */
        public Interval invert(@NonNull Interval other) {
                final @NonNull BigDecimal newmin = min.subtract(other.max);
                final @NonNull BigDecimal newmax = max.subtract(other.min);
                if (newmin.compareTo(newmax) > 0)
                        return EMPTY;
                return new Interval(newmin, newmax);
        }

        @NonNull
        /**
         * 
         * @param value the value to subtract
         * @return Interval with both min and max reduced by value.
         */
        public Interval subtract(@NonNull BigDecimal value) {
                return new Interval(min.subtract(value), max.subtract(value));
        }

        public @NonNull Interval multiply(@NonNull BigDecimal weight) {
                return new Interval(min.multiply(weight), max.multiply(weight));
        }

        @Override
        public @NonNull String toString() {
                return "Interval[" + min + "," + max + "]";
        }

        @NonNull
        /**
         * @param precision number of digits required
         * @return this but with modified precision. The interval is rounded so that
         *         the new interval is inside the old one.
         */
        public Interval round(int precision) {
                return new Interval(min.setScale(precision, RoundingMode.UP),
                                max.setScale(precision, RoundingMode.DOWN));
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((max == null) ? 0 : max.hashCode());
                result = prime * result + ((min == null) ? 0 : min.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;
                Interval other = (Interval) obj;
                if (max == null) {
                        if (other.max != null)
                                return false;

                } else if (max.compareTo(other.max) != 0)
                        // THIS WAS FIXED MANUALLY TO USE COMPARETO
                        return false;
                if (min == null) {
                        if (other.min != null)
                                return false;
                } else if (min.compareTo(other.min) != 0)
                        // THIS WAS FIXED MANUALLY TO USE COMPARETO
                        return false;
                return true;
        }

}