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.
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 2008-2013 jOpenDocument, by ILM Informatique. All rights reserved.
*
* The contents of this file are subject to the terms of the GNU
* General Public License Version 3 only ("GPL").
* You may not use this file except in compliance with the License.
* You can obtain a copy of the License at http://www.gnu.org/licenses/gpl-3.0.html
* See the License for the specific language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each file.
*
*/
package org.jopendocument.util;
import org.jopendocument.util.convertor.NumberConvertor;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
public class NumberUtils {
/**
* Test class and numerical equality. E.g. {@link BigDecimal#equals(Object)} also tests the
* scale.
*
* @param type of number.
* @param n1 first number, can be null.
* @param n2 second number, can be null.
* @return true if n1 and n2 have the same class and are
* numerically equal.
* @see #areNumericallyEqual(Number, Number)
*/
static public final boolean areEqual(final N n1, final N n2) {
if (n1 == null && n2 == null)
return true;
if (n1 == null || n2 == null)
return false;
final Class n1Class = n1.getClass();
if (n1Class != n2.getClass())
return false;
// Atomic* don't implement equals()
if (n1Class == AtomicInteger.class || n1Class == AtomicLong.class)
return n1.longValue() == n2.longValue();
else if (n1Class == BigDecimal.class)
return ((BigDecimal) n1).compareTo((BigDecimal) n2) == 0;
else
return n1.equals(n2);
}
/**
* Test numerical equality (but ignore class).
*
* @param n1 first number, can be null.
* @param n2 second number, can be null.
* @return true if n1 and n2 are numerically equal.
* @see #compare(Number, Number)
*/
static public final boolean areNumericallyEqual(final Number n1, final Number n2) {
if (n1 == null && n2 == null)
return true;
if (n1 == null || n2 == null)
return false;
return compare(n1, n2) == 0;
}
/**
* Compare two arbitrary numbers.
*
* @param n1 first number, not null.
* @param n2 second number, not null.
* @return a negative integer, zero, or a positive integer as n1 is less than, equal to, or
* greater than n2.
* @see Comparable#compareTo(Object)
*/
static public final int compare(final Number n1, final Number n2) {
Class biggerClass = getWiderClass(n1, n2);
// Atomic* aren't Comparable
if (biggerClass == AtomicInteger.class)
biggerClass = Integer.class;
else if (biggerClass == AtomicLong.class)
biggerClass = Long.class;
return compare(n1, n2, biggerClass);
}
static private final int compare(final Number n1, final Number n2, Class clazz) {
final N n1Converted = NumberConvertor.convertExact(n1, clazz);
final N n2Converted = NumberConvertor.convertExact(n2, clazz);
@SuppressWarnings("unchecked")
final Comparable comparable = (Comparable) n1Converted;
return comparable.compareTo(n2Converted);
}
/**
* Return a class wide enough for both numbers. E.g. for Integer and Short, Integer ; for
* BigInteger and Float, BigDecimal.
*
* @param n1 first number, not null.
* @param n2 second number, not null.
* @return a class wide enough for both numbers.
* @see NumberConvertor#convertExact(Number, Class)
*/
static public final Class getWiderClass(final Number n1, final Number n2) {
final Class n1Class = n1.getClass();
final Class n2Class = n2.getClass();
if (n1Class == n2Class)
return n1Class;
if (n1Class == BigDecimal.class || n2Class == BigDecimal.class)
return BigDecimal.class;
final boolean n1isFloat = n1Class == Float.class || n1Class == Double.class;
final boolean n2isFloat = n2Class == Float.class || n2Class == Double.class;
if (n1isFloat && n2isFloat) {
// since classes are different, at least one is Double
return Double.class;
} else if (n1isFloat || n2isFloat) {
// the only class (except the already handled BigDecimal) that can overflow in a Double
// is BigInteger
if (n1Class == BigInteger.class || n2Class == BigInteger.class)
return BigDecimal.class;
else
return Double.class;
}
// integers or BigInteger
if (n1Class == BigInteger.class || n2Class == BigInteger.class)
return BigInteger.class;
else if (n1Class == Long.class || n2Class == Long.class || n1Class == AtomicLong.class || n2Class == AtomicLong.class)
return Long.class;
else if (n1Class == Integer.class || n2Class == Integer.class || n1Class == AtomicInteger.class || n2Class == AtomicInteger.class)
return Integer.class;
else if (n1Class == Short.class || n2Class == Short.class)
return Short.class;
else if (n1Class == Byte.class || n2Class == Byte.class)
return Byte.class;
else
throw new IllegalStateException("Unknown classes " + n1Class + " / " + n2Class);
}
/**
* Whether n has a non-zero fractional part.
*
* @param n a number.
* @return true if there is a non-zero fractional part, e.g. true for
* 1.3d and false for new BigDecimal("1.00").
*/
static public final boolean hasFractionalPart(Number n) {
if (n instanceof Integer || n instanceof Long || n instanceof Short || n instanceof Byte || n instanceof BigInteger || n instanceof AtomicLong || n instanceof AtomicInteger)
return false;
final BigDecimal bd;
if (n instanceof BigDecimal)
bd = (BigDecimal) n;
else if (n instanceof Double || n instanceof Float)
bd = new BigDecimal(n.doubleValue());
else
bd = new BigDecimal(n.toString());
return DecimalUtils.decimalDigits(bd) > 0;
}
static final int MAX_LONG_LENGTH = String.valueOf(Long.MAX_VALUE).length();
static public final int intDigits(final long l) {
final long x = Math.abs(l);
long p = 10;
int i = 1;
while (x >= p && i < MAX_LONG_LENGTH) {
p = 10 * p;
i++;
}
return i;
}
/**
* The number of digits of the integer part in decimal representation.
*
* @param n a number, e.g. 123.45.
* @return the number of digits of the integer part, e.g. 3.
*/
static public final int intDigits(Number n) {
if (n instanceof Integer || n instanceof Long || n instanceof Short || n instanceof Byte || n instanceof AtomicLong || n instanceof AtomicInteger)
return intDigits(n.longValue());
final BigDecimal bd;
if (n instanceof BigDecimal)
bd = (BigDecimal) n;
else if (n instanceof BigInteger)
bd = new BigDecimal((BigInteger) n);
else if (n instanceof Double || n instanceof Float)
bd = new BigDecimal(n.doubleValue());
else
bd = new BigDecimal(n.toString());
return DecimalUtils.intDigits(bd);
}
/**
* High precision divide.
*
* @param n the dividend.
* @param d the divisor.
* @return n / d.
* @see DecimalUtils#HIGH_PRECISION
*/
static public Number divide(Number n, double d) {
if (d == 1)
return n;
if (n instanceof BigDecimal) {
return ((BigDecimal) n).divide(new BigDecimal(d), DecimalUtils.HIGH_PRECISION);
} else if (n instanceof BigInteger) {
return new BigDecimal((BigInteger) n).divide(new BigDecimal(d), DecimalUtils.HIGH_PRECISION);
} else {
return n.doubleValue() / d;
}
}
}