Determines whether the values in the given array of doubles are all equal within a tolerance of #EPSILON - Java java.lang

Java examples for java.lang:Math Array Function

  1. HOME
  2. Java
  3. java.lang
  4. Math Array Function

Description

Determines whether the values in the given array of doubles are all equal within a tolerance of #EPSILON

Demo Code

/**/*  w  ww.java2  s. c  om*/
 * Java Modular Image Synthesis Toolkit (JMIST)
 * Copyright (C) 2008-2013 Bradley W. Kimmel
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Main{
    /**
     * A comparison threshold value to be used when a normal degree of
     * precision is expected.
     */
    public static final double EPSILON = 1e-6;
    /**
     * Determines whether the values in the given array of <code>double</code>s
     * are all equal within a tolerance of {@value #EPSILON}
     * @param array The array of <code>double</code>s to compare.
     * @return A value indicating whether all values in <code>array</code> are
     *     within {@value #EPSILON} of one another.
     * @see #EPSILON
     */
    public static boolean areEqual(double[] array) {
        return areEqual(array, MathUtil.EPSILON);
    }
    /**
     * Determines whether the values in the given collection of
     * <code>double</code>s are all equal within a tolerance of
     * {@value #EPSILON}.
     * @param values The collection of <code>double</code>s to compare.
     * @return A value indicating whether all values in <code>values</code> are
     *     within {@value #EPSILON} of one another.
     * @see #EPSILON
     */
    public static boolean areEqual(Iterable<Double> values) {
        return areEqual(values, MathUtil.EPSILON);
    }
    /**
     * Determines whether the values in the given array of <code>double</code>s
     * are all equal within a specified tolerance.
     * @param array The array of <code>double</code>s to compare.
     * @param epsilon The tolerance.
     * @return A value indicating whether all values in <code>array</code> are
     *     within <code>epsilon</code> of one another.
     */
    public static boolean areEqual(double[] array, double epsilon) {

        if (array.length < 2) {
            return true;
        }

        double min = array[0];
        double max = array[0];

        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
            if (array[i] > max) {
                max = array[i];
            }
            if (!equal(min, max, epsilon)) {
                return false;
            }
        }

        return true;

    }
    /**
     * Determines whether the values in the given collection of
     * <code>double</code>s are all equal within a specified tolerance.
     * @param values The collection of <code>double</code>s to compare.
     * @param epsilon The tolerance.
     * @return A value indicating whether all values in <code>values</code> are
     *     within <code>epsilon</code> of one another.
     */
    public static boolean areEqual(Iterable<Double> values, double epsilon) {

        double min = Double.POSITIVE_INFINITY;
        double max = Double.NEGATIVE_INFINITY;

        for (double x : values) {
            if (x < min) {
                min = x;
            }
            if (x > max) {
                max = x;
            }
            if (!equal(min, max, epsilon)) {
                return false;
            }
        }

        return true;

    }
    /**
     * Determines whether two floating point values are close enough
     * to be considered "equal" (i.e., the difference may be attributed
     * to rounding errors).
     * @param x The first value to compare.
     * @param y The second value to compare.
     * @param epsilon The minimum difference required for the two values
     *     to be considered distinguishable.
     * @return A value indicating whether the difference between x and y
     *     is less than the given threshold.
     */
    public static boolean equal(double x, double y, double epsilon) {
        return Math.abs(x - y) < epsilon;
    }
    /**
     * Determines whether two floating point values are close enough
     * to be considered "equal" (i.e., the difference may be attributed
     * to rounding errors).
     * @param x The first value to compare.
     * @param y The second value to compare.
     * @return A value indicating whether the difference between x and y
     *     is less than MathUtil.EPSILON.
     * @see #EPSILON
     */
    public static boolean equal(double x, double y) {
        return Math.abs(x - y) < MathUtil.EPSILON;
    }
}

Related Tutorials