src/main/java/org/apache/commons/math4/util/MathUtils.java - commons-math - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.commons.math4.util;

 import java.util.Arrays;

 import org.apache.commons.math4.RealFieldElement;
 import org.apache.commons.math4.exception.MathArithmeticException;
 import org.apache.commons.math4.exception.NotFiniteNumberException;
 import org.apache.commons.math4.exception.NullArgumentException;
 import org.apache.commons.math4.exception.util.Localizable;
 import org.apache.commons.math4.exception.util.LocalizedFormats;

 /**
  * Miscellaneous utility functions.
  *
  * @see MathArrays
  *
  */
 public final class MathUtils {
     /**
      * \(2\pi\)
      * @since 2.1
      */
     public static final double TWO_PI = 2 * FastMath.PI;

     /**
      * \(\pi^2\)
      * @since 3.4
      */
     public static final double PI_SQUARED = FastMath.PI * FastMath.PI;


     /**
      * Class contains only static methods.
      */
     private MathUtils() {}


     /**
      * Returns an integer hash code representing the given double value.
      *
      * @param value the value to be hashed
      * @return the hash code
      */
     public static int hash(double value) {
         return Double.valueOf(value).hashCode();
     }

     /**
      * Returns {@code true} if the values are equal according to semantics of
      * {@link Double#equals(Object)}.
      *
      * @param x Value
      * @param y Value
      * @return {@code Double.valueOf(x).equals(Double.valueOf(y))}
      */
     public static boolean equals(double x, double y) {
         return Double.valueOf(x).equals(Double.valueOf(y));
     }

     /**
      * Returns an integer hash code representing the given double array.
      *
      * @param value the value to be hashed (may be null)
      * @return the hash code
      * @since 1.2
      */
     public static int hash(double[] value) {
         return Arrays.hashCode(value);
     }

      /** Find the maximum of two field elements.
       * @param <T> the type of the field elements
       * @param e1 first element
       * @param e2 second element
       * @return max(a1, e2)
       * @since 3.6
       */
      public static <T extends RealFieldElement<T>> T max(final T e1, final T e2) {
          return e1.subtract(e2).getReal() >= 0 ? e1 : e2;
      }

      /** Find the minimum of two field elements.
       * @param <T> the type of the field elements
       * @param e1 first element
       * @param e2 second element
       * @return min(a1, e2)
       * @since 3.6
       */
      public static <T extends RealFieldElement<T>> T min(final T e1, final T e2) {
          return e1.subtract(e2).getReal() >= 0 ? e2 : e1;
      }

     /**
      * <p>Reduce {@code |a - offset|} to the primary interval
      * {@code [0, |period|)}.</p>
      *
      * <p>Specifically, the value returned is <br>
      * {@code a - |period| * floor((a - offset) / |period|) - offset}.</p>
      *
      * <p>If any of the parameters are {@code NaN} or infinite, the result is
      * {@code NaN}.</p>
      *
      * @param a Value to reduce.
      * @param period Period.
      * @param offset Value that will be mapped to {@code 0}.
      * @return the value, within the interval {@code [0 |period|)},
      * that corresponds to {@code a}.
      */
     public static double reduce(double a,
                                 double period,
                                 double offset) {
         final double p = FastMath.abs(period);
         return a - p * FastMath.floor((a - offset) / p) - offset;
     }

     /**
      * Returns the first argument with the sign of the second argument.
      *
      * @param magnitude Magnitude of the returned value.
      * @param sign Sign of the returned value.
      * @return a value with magnitude equal to {@code magnitude} and with the
      * same sign as the {@code sign} argument.
      * @throws MathArithmeticException if {@code magnitude == Byte.MIN_VALUE}
      * and {@code sign >= 0}.
      */
     public static byte copySign(byte magnitude, byte sign)
         throws MathArithmeticException {
         if ((magnitude >= 0 && sign >= 0) ||
             (magnitude < 0 && sign < 0)) { // Sign is OK.
             return magnitude;
         } else if (sign >= 0 &&
                    magnitude == Byte.MIN_VALUE) {
             throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
         } else {
             return (byte) -magnitude; // Flip sign.
         }
     }

     /**
      * Returns the first argument with the sign of the second argument.
      *
      * @param magnitude Magnitude of the returned value.
      * @param sign Sign of the returned value.
      * @return a value with magnitude equal to {@code magnitude} and with the
      * same sign as the {@code sign} argument.
      * @throws MathArithmeticException if {@code magnitude == Short.MIN_VALUE}
      * and {@code sign >= 0}.
      */
     public static short copySign(short magnitude, short sign)
             throws MathArithmeticException {
         if ((magnitude >= 0 && sign >= 0) ||
             (magnitude < 0 && sign < 0)) { // Sign is OK.
             return magnitude;
         } else if (sign >= 0 &&
                    magnitude == Short.MIN_VALUE) {
             throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
         } else {
             return (short) -magnitude; // Flip sign.
         }
     }

     /**
      * Returns the first argument with the sign of the second argument.
      *
      * @param magnitude Magnitude of the returned value.
      * @param sign Sign of the returned value.
      * @return a value with magnitude equal to {@code magnitude} and with the
      * same sign as the {@code sign} argument.
      * @throws MathArithmeticException if {@code magnitude == Integer.MIN_VALUE}
      * and {@code sign >= 0}.
      */
     public static int copySign(int magnitude, int sign)
             throws MathArithmeticException {
         if ((magnitude >= 0 && sign >= 0) ||
             (magnitude < 0 && sign < 0)) { // Sign is OK.
             return magnitude;
         } else if (sign >= 0 &&
                    magnitude == Integer.MIN_VALUE) {
             throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
         } else {
             return -magnitude; // Flip sign.
         }
     }

     /**
      * Returns the first argument with the sign of the second argument.
      *
      * @param magnitude Magnitude of the returned value.
      * @param sign Sign of the returned value.
      * @return a value with magnitude equal to {@code magnitude} and with the
      * same sign as the {@code sign} argument.
      * @throws MathArithmeticException if {@code magnitude == Long.MIN_VALUE}
      * and {@code sign >= 0}.
      */
     public static long copySign(long magnitude, long sign)
         throws MathArithmeticException {
         if ((magnitude >= 0 && sign >= 0) ||
             (magnitude < 0 && sign < 0)) { // Sign is OK.
             return magnitude;
         } else if (sign >= 0 &&
                    magnitude == Long.MIN_VALUE) {
             throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
         } else {
             return -magnitude; // Flip sign.
         }
     }
     /**
      * Check that the argument is a real number.
      *
      * @param x Argument.
      * @throws NotFiniteNumberException if {@code x} is not a
      * finite real number.
      */
     public static void checkFinite(final double x)
         throws NotFiniteNumberException {
         if (Double.isInfinite(x) || Double.isNaN(x)) {
             throw new NotFiniteNumberException(x);
         }
     }

     /**
      * Check that all the elements are real numbers.
      *
      * @param val Arguments.
      * @throws NotFiniteNumberException if any values of the array is not a
      * finite real number.
      */
     public static void checkFinite(final double[] val)
         throws NotFiniteNumberException {
         for (int i = 0; i < val.length; i++) {
             final double x = val[i];
             if (Double.isInfinite(x) || Double.isNaN(x)) {
                 throw new NotFiniteNumberException(LocalizedFormats.ARRAY_ELEMENT, x, i);
             }
         }
     }

     /**
      * Checks that an object is not null.
      *
      * @param o Object to be checked.
      * @param pattern Message pattern.
      * @param args Arguments to replace the placeholders in {@code pattern}.
      * @throws NullArgumentException if {@code o} is {@code null}.
      */
     public static void checkNotNull(Object o,
                                     Localizable pattern,
                                     Object ... args)
         throws NullArgumentException {
         if (o == null) {
             throw new NullArgumentException(pattern, args);
         }
     }

     /**
      * Checks that an object is not null.
      *
      * @param o Object to be checked.
      * @throws NullArgumentException if {@code o} is {@code null}.
      */
     public static void checkNotNull(Object o)
         throws NullArgumentException {
         if (o == null) {
             throw new NullArgumentException();
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.commons.math4.util;

	import java.util.Arrays;

	import org.apache.commons.math4.RealFieldElement;
	import org.apache.commons.math4.exception.MathArithmeticException;
	import org.apache.commons.math4.exception.NotFiniteNumberException;
	import org.apache.commons.math4.exception.NullArgumentException;
	import org.apache.commons.math4.exception.util.Localizable;
	import org.apache.commons.math4.exception.util.LocalizedFormats;

	/**
	* Miscellaneous utility functions.
	*
	* @see MathArrays
	*
	*/
	public final class MathUtils {
	/**
	* \(2\pi\)
	* @since 2.1
	*/
	public static final double TWO_PI = 2 * FastMath.PI;

	/**
	* \(\pi^2\)
	* @since 3.4
	*/
	public static final double PI_SQUARED = FastMath.PI * FastMath.PI;


	/**
	* Class contains only static methods.
	*/
	private MathUtils() {}


	/**
	* Returns an integer hash code representing the given double value.
	*
	* @param value the value to be hashed
	* @return the hash code
	*/
	public static int hash(double value) {
	return Double.valueOf(value).hashCode();
	}

	/**
	* Returns {@code true} if the values are equal according to semantics of
	* {@link Double#equals(Object)}.
	*
	* @param x Value
	* @param y Value
	* @return {@code Double.valueOf(x).equals(Double.valueOf(y))}
	*/
	public static boolean equals(double x, double y) {
	return Double.valueOf(x).equals(Double.valueOf(y));
	}

	/**
	* Returns an integer hash code representing the given double array.
	*
	* @param value the value to be hashed (may be null)
	* @return the hash code
	* @since 1.2
	*/
	public static int hash(double[] value) {
	return Arrays.hashCode(value);
	}

	/** Find the maximum of two field elements.
	* @param <T> the type of the field elements
	* @param e1 first element
	* @param e2 second element
	* @return max(a1, e2)
	* @since 3.6
	*/
	public static <T extends RealFieldElement<T>> T max(final T e1, final T e2) {
	return e1.subtract(e2).getReal() >= 0 ? e1 : e2;
	}

	/** Find the minimum of two field elements.
	* @param <T> the type of the field elements
	* @param e1 first element
	* @param e2 second element
	* @return min(a1, e2)
	* @since 3.6
	*/
	public static <T extends RealFieldElement<T>> T min(final T e1, final T e2) {
	return e1.subtract(e2).getReal() >= 0 ? e2 : e1;
	}

	/**
	* <p>Reduce {@code \|a - offset\|} to the primary interval
	* {@code [0, \|period\|)}.</p>
	*
	* <p>Specifically, the value returned is <br>
	* {@code a - \|period\| * floor((a - offset) / \|period\|) - offset}.</p>
	*
	* <p>If any of the parameters are {@code NaN} or infinite, the result is
	* {@code NaN}.</p>
	*
	* @param a Value to reduce.
	* @param period Period.
	* @param offset Value that will be mapped to {@code 0}.
	* @return the value, within the interval {@code [0 \|period\|)},
	* that corresponds to {@code a}.
	*/
	public static double reduce(double a,
	double period,
	double offset) {
	final double p = FastMath.abs(period);
	return a - p * FastMath.floor((a - offset) / p) - offset;
	}

	/**
	* Returns the first argument with the sign of the second argument.
	*
	* @param magnitude Magnitude of the returned value.
	* @param sign Sign of the returned value.
	* @return a value with magnitude equal to {@code magnitude} and with the
	* same sign as the {@code sign} argument.
	* @throws MathArithmeticException if {@code magnitude == Byte.MIN_VALUE}
	* and {@code sign >= 0}.
	*/
	public static byte copySign(byte magnitude, byte sign)
	throws MathArithmeticException {
	if ((magnitude >= 0 && sign >= 0) \|\|
	(magnitude < 0 && sign < 0)) { // Sign is OK.
	return magnitude;
	} else if (sign >= 0 &&
	magnitude == Byte.MIN_VALUE) {
	throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
	} else {
	return (byte) -magnitude; // Flip sign.
	}
	}

	/**
	* Returns the first argument with the sign of the second argument.
	*
	* @param magnitude Magnitude of the returned value.
	* @param sign Sign of the returned value.
	* @return a value with magnitude equal to {@code magnitude} and with the
	* same sign as the {@code sign} argument.
	* @throws MathArithmeticException if {@code magnitude == Short.MIN_VALUE}
	* and {@code sign >= 0}.
	*/
	public static short copySign(short magnitude, short sign)
	throws MathArithmeticException {
	if ((magnitude >= 0 && sign >= 0) \|\|
	(magnitude < 0 && sign < 0)) { // Sign is OK.
	return magnitude;
	} else if (sign >= 0 &&
	magnitude == Short.MIN_VALUE) {
	throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
	} else {
	return (short) -magnitude; // Flip sign.
	}
	}

	/**
	* Returns the first argument with the sign of the second argument.
	*
	* @param magnitude Magnitude of the returned value.
	* @param sign Sign of the returned value.
	* @return a value with magnitude equal to {@code magnitude} and with the
	* same sign as the {@code sign} argument.
	* @throws MathArithmeticException if {@code magnitude == Integer.MIN_VALUE}
	* and {@code sign >= 0}.
	*/
	public static int copySign(int magnitude, int sign)
	throws MathArithmeticException {
	if ((magnitude >= 0 && sign >= 0) \|\|
	(magnitude < 0 && sign < 0)) { // Sign is OK.
	return magnitude;
	} else if (sign >= 0 &&
	magnitude == Integer.MIN_VALUE) {
	throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
	} else {
	return -magnitude; // Flip sign.
	}
	}

	/**
	* Returns the first argument with the sign of the second argument.
	*
	* @param magnitude Magnitude of the returned value.
	* @param sign Sign of the returned value.
	* @return a value with magnitude equal to {@code magnitude} and with the
	* same sign as the {@code sign} argument.
	* @throws MathArithmeticException if {@code magnitude == Long.MIN_VALUE}
	* and {@code sign >= 0}.
	*/
	public static long copySign(long magnitude, long sign)
	throws MathArithmeticException {
	if ((magnitude >= 0 && sign >= 0) \|\|
	(magnitude < 0 && sign < 0)) { // Sign is OK.
	return magnitude;
	} else if (sign >= 0 &&
	magnitude == Long.MIN_VALUE) {
	throw new MathArithmeticException(LocalizedFormats.OVERFLOW);
	} else {
	return -magnitude; // Flip sign.
	}
	}
	/**
	* Check that the argument is a real number.
	*
	* @param x Argument.
	* @throws NotFiniteNumberException if {@code x} is not a
	* finite real number.
	*/
	public static void checkFinite(final double x)
	throws NotFiniteNumberException {
	if (Double.isInfinite(x) \|\| Double.isNaN(x)) {
	throw new NotFiniteNumberException(x);
	}
	}

	/**
	* Check that all the elements are real numbers.
	*
	* @param val Arguments.
	* @throws NotFiniteNumberException if any values of the array is not a
	* finite real number.
	*/
	public static void checkFinite(final double[] val)
	throws NotFiniteNumberException {
	for (int i = 0; i < val.length; i++) {
	final double x = val[i];
	if (Double.isInfinite(x) \|\| Double.isNaN(x)) {
	throw new NotFiniteNumberException(LocalizedFormats.ARRAY_ELEMENT, x, i);
	}
	}
	}

	/**
	* Checks that an object is not null.
	*
	* @param o Object to be checked.
	* @param pattern Message pattern.
	* @param args Arguments to replace the placeholders in {@code pattern}.
	* @throws NullArgumentException if {@code o} is {@code null}.
	*/
	public static void checkNotNull(Object o,
	Localizable pattern,
	Object ... args)
	throws NullArgumentException {
	if (o == null) {
	throw new NullArgumentException(pattern, args);
	}
	}

	/**
	* Checks that an object is not null.
	*
	* @param o Object to be checked.
	* @throws NullArgumentException if {@code o} is {@code null}.
	*/
	public static void checkNotNull(Object o)
	throws NullArgumentException {
	if (o == null) {
	throw new NullArgumentException();
	}
	}
	}