Java FastMath.getExponent方法代码示例

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/**
 * <p>
 * Gets the fraction as a {@code double}. This calculates the fraction as
 * the numerator divided by denominator.
 * </p>
 *
 * @return the fraction as a {@code double}
 * @see java.lang.Number#doubleValue()
 */
@Override
public double doubleValue() {
    double result = numerator.doubleValue() / denominator.doubleValue();
    if (Double.isNaN(result)) {
        // Numerator and/or denominator must be out of range:
        // Calculate how far to shift them to put them in range.
        int shift = FastMath.max(numerator.bitLength(),
                                 denominator.bitLength()) - FastMath.getExponent(Double.MAX_VALUE);
        result = numerator.shiftRight(shift).doubleValue() /
            denominator.shiftRight(shift).doubleValue();
    }
    return result;
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/**
 * <p>
 * Gets the fraction as a {@code float}. This calculates the fraction as
 * the numerator divided by denominator.
 * </p>
 *
 * @return the fraction as a {@code float}.
 * @see java.lang.Number#floatValue()
 */
@Override
public float floatValue() {
    float result = numerator.floatValue() / denominator.floatValue();
    if (Double.isNaN(result)) {
        // Numerator and/or denominator must be out of range:
        // Calculate how far to shift them to put them in range.
        int shift = FastMath.max(numerator.bitLength(),
                                 denominator.bitLength()) - FastMath.getExponent(Float.MAX_VALUE);
        result = numerator.shiftRight(shift).floatValue() /
            denominator.shiftRight(shift).floatValue();
    }
    return result;
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
public SparseGradient hypot(final SparseGradient y) {
    if (Double.isInfinite(value) || Double.isInfinite(y.value)) {
        return createConstant(Double.POSITIVE_INFINITY);
    } else if (Double.isNaN(value) || Double.isNaN(y.value)) {
        return createConstant(Double.NaN);
    } else {

        final int expX = FastMath.getExponent(value);
        final int expY = FastMath.getExponent(y.value);
        if (expX > expY + 27) {
            // y is negligible with respect to x
            return abs();
        } else if (expY > expX + 27) {
            // x is negligible with respect to y
            return y.abs();
        } else {

            // find an intermediate scale to avoid both overflow and underflow
            final int middleExp = (expX + expY) / 2;

            // scale parameters without losing precision
            final SparseGradient scaledX = scalb(-middleExp);
            final SparseGradient scaledY = y.scalb(-middleExp);

            // compute scaled hypotenuse
            final SparseGradient scaledH =
                    scaledX.multiply(scaledX).add(scaledY.multiply(scaledY)).sqrt();

            // remove scaling
            return scaledH.scalb(middleExp);

        }

    }
}
 

import org.apache.commons.math3.util.FastMath; //导入方法依赖的package包/类
/**
 * Return the exponent of the instance value, removing the bias.
 * <p>
 * For double numbers of the form 2<sup>x</sup>, the unbiased
 * exponent is exactly x.
 * </p>
 * @return exponent for instance in IEEE754 representation, without bias
 */
public int getExponent() {
    return FastMath.getExponent(data[0]);
}