• Home
• org.codeprimate
• cp-elements
• 1.0.0.M5
• source code
• NumberUtils.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.cp.elements.lang.NumberUtils Maven / Gradle / Ivy

/*
 * Copyright 2016 Author or Authors.
 *
 * Licensed 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.cp.elements.lang;

import java.math.BigInteger;

import org.cp.elements.lang.annotation.NullSafe;

/**
 * The {@link NumberUtils} class is an abstract utility class encapsulating common functionality
 * for working with {@link Number Numbers}.
 *
 * @author John J. Blum
 * @see java.lang.Number
 * @since 1.0.0
 */
public abstract class NumberUtils {

  /**
   * Gets the individual bytes of an integer (int) value.  An integer is a 32-bit value consisting of 4 bytes
   * where each byte of the integer (int) value is returned in an element of a 4-element byte array.
   *
   * @param value the integer (int) value to convert into a byte array consisting of the int value's 4 bytes
   * (or 32-bit value).
   * @return a byte array containing the individual bytes making up the value of the integer (int).
   */
  public static byte[] getBytes(int value) {

    byte[] valueBytes = new byte[4];

    valueBytes[0] = (byte) (value >>> 24 & 0xFF);
    valueBytes[1] = (byte) (value >>> 16 & 0xFF);
    valueBytes[2] = (byte) (value >>> 8 & 0xFF);
    valueBytes[3] = (byte) (value & 0xFF);

    return valueBytes;
  }

  /**
   * Determines whether the specified double is a floating-point number, which is defined as a double value having a
   * fractional value (a non-zero value after the decimal point).
   *
   * @param value the double value being evaluated as a decimal value (floating-point value).
   * @return a boolean value indicating whether the specified double value is a floating-point number.
   * @see #isWhole(double)
   */
  public static boolean isDecimal(double value) {
    return (Math.floor(value) != value);
  }

  /**
   * Determines whether the given {@link Number} is a decimal value.
   *
   * The {@link Number} is considered a decimal value if it is instance of {@link Double} or {@link Float}.
   *
   * @param value {@link Number} to evaluate.
   * @return a boolean value indicating whether the given {@link Number} is a decimal value.
   * @see java.lang.Double
   * @see java.lang.Float
   * @see java.lang.Number
   */
  @NullSafe
  public static boolean isDecimal(Number value) {
    return (value instanceof Float || value instanceof Double);
  }

  /**
   * Determines whether the specified long value is an even number using modulus, which is any number divisible by 2
   * with a remainder of 0.
   *
   * @param value the long value being evaluated as an even number.
   * @return a boolean value indicating whether the specified long value is even.
   * @see #isBitwiseEven(long)
   * @see #isOdd(long)
   */
  public static boolean isEven(long value) {
    return (Math.abs(value) % 2L == 0);
  }

  /**
   * Determines whether the specified long value is an even number using bitwise 'AND', which is any number
   * with a 0 in the 0 position of the binary representation of the number.
   *
   * @param value the long value being evaluated as an even number.
   * @return a boolean value indicating whether the specified long value is even.
   * @see #isEven(long)
   */
  public static boolean isBitwiseEven(long value) {
    return ((1L & Math.abs(value)) == 0L);
  }

  /**
   * Determines whether the specified double value is negative (less than 0).
   *
   * @param value a double who's value is evaluated as a negative value (less than 0).
   * @return a boolean value indicating whether the specified double value is negative (less than 0).
   * @see #isPositive(double)
   */
  public static boolean isNegative(double value) {
    return (value < 0.0d);
  }

  /**
   * Determines whether the specified long value is an odd number using modulus, which is any number
   * having a remainder of 1 when divided by 2.
   *
   * @param value the long value being evaluated as an odd number.
   * @return a boolean value indicating whether the specified long value is odd.
   * @see #isBitwiseOdd(long)
   * @see #isEven(long)
   */
  public static boolean isOdd(long value) {
    return (Math.abs(value) % 2L == 1);
  }

  /**
   * Determines whether the specified long value is an odd number using bitwise 'AND', which is any number
   * with a 1 in the 0 position of the binary representation of the number.
   *
   * @param value the long value being evaluated as an odd number.
   * @return a boolean value indicating whether the specified long value is odd.
   * @see #isOdd(long)
   */
  public static boolean isBitwiseOdd(long value) {
    return ((1L & Math.abs(value)) == 1L);
  }

  /**
   * Determines whether the specified double value is positive (greater than 0).
   *
   * @param value a double who's value is evaluated as a positive value (greater than 0).
   * @return a boolean value indicating whether the specified double value is positive (greater than 0).
   * @see #isNegative(double)
   */
  public static boolean isPositive(double value) {
    return (value > 0.0d);
  }

  /**
   * Determines whether the specified double is a whole number, which is defined as a double value having no
   * fractional value (containing only zeroes after the decimal point).
   *
   * @param value the double value being evaluated as a whole value (integral value).
   * @return a boolean value indicating whether the specified double value is a whole number.
   * @see #isDecimal(double)
   */
  public static boolean isWhole(double value) {
    return (Math.floor(value) == value);
  }

  /* (non-Javadoc) */
  @NullSafe
  public static boolean isWhole(Number value) {
    return (value instanceof Byte || value instanceof Short || value instanceof Integer || value instanceof Long
      || value instanceof BigInteger);
  }

  /**
   * Determines whether the given double value is zero.
   *
   * @param value double value to evaluate.
   * @return a boolean value indicating whether the given double value is zero.
   */
  public static boolean isZero(double value) {
    return (value == 0.0d);
  }

  /**
   * Determines whether the given {@link Number} is a {@link Byte}.
   *
   * If the {@link Number} is not an instance of {@link Byte} then the numerical value must be between
   * {@link Byte#MIN_VALUE} and {@link Byte#MAX_VALUE} inclusive.
   *
   * @param value {@link Number} to evaluate.
   * @return a boolean value indicating whether the given {@link Number} is a {@link Byte}.
   * @see #isWhole(Number)
   * @see java.lang.Number
   * @see java.lang.Byte
   */
  @NullSafe
  public static boolean isByte(Number value) {
    return (value instanceof Byte
      || (isWhole(value) && value.longValue() >= Byte.MIN_VALUE && value.longValue() <= Byte.MAX_VALUE));
  }

  /**
   * Determines whether the given {@link Number} is a {@link Short}.
   *
   * If the {@link Number} is not an instance of {@link Short} then the numerical value must be between
   * {@link Short#MIN_VALUE} and {@link Short#MAX_VALUE} inclusive.
   *
   * @param value {@link Number} to evaluate.
   * @return a boolean value indicating whether the given {@link Number} is a {@link Short}.
   * @see #isWhole(Number)
   * @see java.lang.Number
   * @see java.lang.Short
   */
  @NullSafe
  public static boolean isShort(Number value) {
    return (value instanceof Short
      || (isWhole(value) && value.longValue() >= Short.MIN_VALUE && value.longValue() <= Short.MAX_VALUE));
  }

  /**
   * Determines whether the given {@link Number} is a {@link Integer}.
   *
   * If the {@link Number} is not an instance of {@link Integer} then the numerical value must be between
   * {@link Integer#MIN_VALUE} and {@link Integer#MAX_VALUE} inclusive.
   *
   * @param value {@link Number} to evaluate.
   * @return a boolean value indicating whether the given {@link Number} is a {@link Integer}.
   * @see #isWhole(Number)
   * @see java.lang.Number
   * @see java.lang.Integer
   */
  @NullSafe
  public static boolean isInteger(Number value) {
    return (value instanceof Integer
      || (isWhole(value) && value.longValue() >= Integer.MIN_VALUE && value.longValue() <= Integer.MAX_VALUE));
  }

  /**
   * Determines whether the given {@link Number} is a {@link Long}.
   *
   * The {@link Number} must be an instance of {@link Long}.
   *
   * @param value {@link Number} to evaluate.
   * @return a boolean value indicating whether the given {@link Number} is a {@link Long}.
   * @see java.lang.Number
   * @see java.lang.Long
   */
  @NullSafe
  public static boolean isLong(Number value) {
    return (value instanceof Long);
  }

  /**
   * Determines whether the given {@link Number} is a {@link Float}.
   *
   * If the {@link Number} is not an instance of {@link Float} then the numerical value must be between
   * {@link Float#MIN_VALUE} and {@link Float#MAX_VALUE} inclusive.
   *
   * @param value {@link Number} to evaluate.
   * @return a boolean value indicating whether the given {@link Number} is a {@link Float}.
   * @see #isDecimal(Number)
   * @see java.lang.Number
   * @see java.lang.Float
   */
  @NullSafe
  public static boolean isFloat(Number value) {
    return (value instanceof Float
      || (isDecimal(value) && value.doubleValue() >= Float.MIN_VALUE && value.doubleValue() <= Float.MAX_VALUE));
  }

  /**
   * Determines whether the given {@link Number} is a {@link Double}.
   *
   * The {@link Number} must be an instance of {@link Double}.
   *
   * @param value {@link Number} to evaluate.
   * @return a boolean value indicating whether the given {@link Number} is a {@link Double}.
   * @see java.lang.Number
   * @see java.lang.Double
   */
  @NullSafe
  public static boolean isDouble(Number value) {
    return (value instanceof Double);
  }

  /**
   * Returns the byte value of the given {@link Number} or 0 if {@link Number} is {@literal null}.
   *
   * @param number {@link Number} to evaluate.
   * @return the byte value of the given {@link Number} or 0 if the {@link Number} is {@literal null}.
   * @see java.lang.Number#byteValue()
   */
  @NullSafe
  public static byte byteValue(Number number) {
    return (number != null ? number.byteValue() : 0);
  }

  /**
   * Returns the short value of the given {@link Number} or 0 if {@link Number} is {@literal null}.
   *
   * @param number {@link Number} to evaluate.
   * @return the short value of the given {@link Number} or 0 if the {@link Number} is {@literal null}.
   * @see java.lang.Number#shortValue()
   */
  @NullSafe
  public static short shortValue(Number number) {
    return (number != null ? number.shortValue() : 0);
  }

  /**
   * Returns the int value of the given {@link Number} or 0 if {@link Number} is {@literal null}.
   *
   * @param number {@link Number} to evaluate.
   * @return the int value of the given {@link Number} or 0 if the {@link Number} is {@literal null}.
   * @see java.lang.Number#intValue()
   */
  @NullSafe
  public static int intValue(Number number) {
    return (number != null ? number.intValue() : 0);
  }

  /**
   * Returns the long value of the given {@link Number} or 0L if {@link Number} is {@literal null}.
   *
   * @param number {@link Number} to evaluate.
   * @return the long value of the given {@link Number} or 0L if the {@link Number} is {@literal null}.
   * @see java.lang.Number#longValue()
   */
  @NullSafe
  public static long longValue(Number number) {
    return (number != null ? number.longValue() : 0L);
  }

  /**
   * Returns the float value of the given {@link Number} or 0.0f if {@link Number} is {@literal null}.
   *
   * @param number {@link Number} to evaluate.
   * @return the float value of the given {@link Number} or 0.0f if the {@link Number} is {@literal null}.
   * @see java.lang.Number#floatValue()
   */
  @NullSafe
  public static float floatValue(Number number) {
    return (number != null ? number.floatValue() : 0.0f);
  }

  /**
   * Returns the double value of the given {@link Number} or 0.0d if {@link Number} is {@literal null}.
   *
   * @param number {@link Number} to evaluate.
   * @return the double value of the given {@link Number} or 0.0d if the {@link Number} is {@literal null}.
   * @see java.lang.Number#doubleValue()
   */
  @NullSafe
  public static double doubleValue(Number number) {
    return (number != null ? number.doubleValue() : 0.0d);
  }

  /**
   * Return the primitive byte value of the specified {@link Byte} wrapper object, or 0
   * if the {@link Byte} wrapper object is {@literal null}.
   *
   * @param value {@link Byte} to evaluate.
   * @return a primitive byte value for the specified {@link Byte}, or 0 if the {@link Byte} is {@literal null}.
   * @see #byteValue(Number)
   * @see java.lang.Byte
   */
  @NullSafe
  public static byte valueOf(Byte value) {
    return byteValue(value);
  }

  /**
   * Return the primitive short value of the specified {@link Short} wrapper object, or 0
   * if the {@link Short} wrapper object is {@literal null}.
   *
   * @param value {@link Short} to evaluate.
   * @return a primitive short value for the specified {@link Short}, or 0 if the {@link Short} is {@literal null}.
   * @see #shortValue(Number)
   * @see java.lang.Short
   */
  @NullSafe
  public static short valueOf(Short value) {
    return shortValue(value);
  }

  /**
   * Return the primitive int value of the specified {@link Integer} wrapper object, or 0
   * if the {@link Integer} wrapper object is {@literal null}.
   *
   * @param value {@link Integer} to evaluate.
   * @return a primitive int value for the specified {@link Integer}, or 0 if the {@link Integer} is {@literal null}.
   * @see #intValue(Number)
   * @see java.lang.Integer
   */
  @NullSafe
  public static int valueOf(Integer value) {
    return intValue(value);
  }

  /**
   * Return the primitive long value of the specified {@link Long} wrapper object, or 0
   * if the {@link Long} wrapper object is {@literal null}.
   *
   * @param value {@link Long} to evaluate.
   * @return a primitive long value for the specified {@link Long}, or 0 if the {@link Long} is {@literal null}.
   * @see #longValue(Number)
   * @see java.lang.Long
   */
  @NullSafe
  public static long valueOf(Long value) {
    return longValue(value);
  }

  /**
   * Return the primitive float value of the specified {@link Float} wrapper object, or 0
   * if the {@link Float} wrapper object is {@literal null}.
   *
   * @param value {@link Float} to evaluate.
   * @return a primitive float value for the specified {@link Float}, or 0 if the {@link Float} is {@literal null}.
   * @see #floatValue(Number)
   * @see java.lang.Float
   */
  @NullSafe
  public static float valueOf(Float value) {
    return floatValue(value);
  }

  /**
   * Return the primitive double value of the specified {@link Double} wrapper object, or 0
   * if the {@link Double} wrapper object is {@literal null}.
   *
   * @param value {@link Double} to evaluate.
   * @return a primitive double value for the specified {@link Double}, or 0 if the {@link Double} is {@literal null}.
   * @see #doubleValue(Number)
   * @see java.lang.Double
   */
  @NullSafe
  public static double valueOf(Double value) {
    return doubleValue(value);
  }
}