/*
* 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.harmony.luni.util;
public final class NumberConverter {
private int setCount; // number of times u and k have been gotten
private int getCount; // number of times u and k have been set
private int[] uArray = new int[64];
private int firstK;
private final static double invLogOfTenBaseTwo = Math.log(2.0)
/ Math.log(10.0);
private final static long[] TEN_TO_THE = new long[20];
static {
TEN_TO_THE[0] = 1L;
for (int i = 1; i < TEN_TO_THE.length; ++i) {
long previous = TEN_TO_THE[i - 1];
TEN_TO_THE[i] = (previous << 1) + (previous << 3);
}
}
private static NumberConverter getConverter() {
return new NumberConverter();
}
public static String convert(double input) {
return getConverter().convertD(input);
}
public static String convert(float input) {
return getConverter().convertF(input);
}
public String convertD(double inputNumber) {
int p = 1023 + 52; // the power offset (precision)
long signMask = 0x8000000000000000L; // the mask to get the sign of
// the number
long eMask = 0x7FF0000000000000L; // the mask to get the power bits
long fMask = 0x000FFFFFFFFFFFFFL; // the mask to get the significand
// bits
long inputNumberBits = Double.doubleToLongBits(inputNumber);
// the value of the sign... 0 is positive, ~0 is negative
String signString = (inputNumberBits & signMask) == 0 ? "" : "-";
// the value of the 'power bits' of the inputNumber
int e = (int) ((inputNumberBits & eMask) >> 52);
// the value of the 'significand bits' of the inputNumber
long f = inputNumberBits & fMask;
boolean mantissaIsZero = f == 0;
int pow = 0, numBits = 52;
if (e == 2047)
return mantissaIsZero ? signString + "Infinity" : "NaN";
if (e == 0) {
if (mantissaIsZero)
return signString + "0.0";
if (f == 1)
// special case to increase precision even though 2 *
// Double.MIN_VALUE is 1.0e-323
return signString + "4.9E-324";
pow = 1 - p; // a denormalized number
long ff = f;
while ((ff & 0x0010000000000000L) == 0) {
ff = ff << 1;
numBits--;
}
} else {
// 0 < e < 2047
// a "normalized" number
f = f | 0x0010000000000000L;
pow = e - p;
}
if (-59 < pow && pow < 6 || (pow == -59 && !mantissaIsZero))
longDigitGenerator(f, pow, e == 0, mantissaIsZero, numBits);
else
bigIntDigitGeneratorInstImpl(f, pow, e == 0, mantissaIsZero,
numBits);
if (inputNumber >= 1e7D || inputNumber <= -1e7D
|| (inputNumber > -1e-3D && inputNumber < 1e-3D))
return signString + freeFormatExponential();
return signString + freeFormat();
}
public String convertF(float inputNumber) {
int p = 127 + 23; // the power offset (precision)
int signMask = 0x80000000; // the mask to get the sign of the number
int eMask = 0x7F800000; // the mask to get the power bits
int fMask = 0x007FFFFF; // the mask to get the significand bits
int inputNumberBits = Float.floatToIntBits(inputNumber);
// the value of the sign... 0 is positive, ~0 is negative
String signString = (inputNumberBits & signMask) == 0 ? "" : "-";
// the value of the 'power bits' of the inputNumber
int e = (inputNumberBits & eMask) >> 23;
// the value of the 'significand bits' of the inputNumber
int f = inputNumberBits & fMask;
boolean mantissaIsZero = f == 0;
int pow = 0, numBits = 23;
if (e == 255)
return mantissaIsZero ? signString + "Infinity" : "NaN";
if (e == 0) {
if (mantissaIsZero)
return signString + "0.0";
pow = 1 - p; // a denormalized number
if (f < 8) { // want more precision with smallest values
f = f << 2;
pow -= 2;
}
int ff = f;
while ((ff & 0x00800000) == 0) {
ff = ff << 1;
numBits--;
}
} else {
// 0 < e < 255
// a "normalized" number
f = f | 0x00800000;
pow = e - p;
}
if (-59 < pow && pow < 35 || (pow == -59 && !mantissaIsZero))
longDigitGenerator(f, pow, e == 0, mantissaIsZero, numBits);
else
bigIntDigitGeneratorInstImpl(f, pow, e == 0, mantissaIsZero,
numBits);
if (inputNumber >= 1e7f || inputNumber <= -1e7f
|| (inputNumber > -1e-3f && inputNumber < 1e-3f))
return signString + freeFormatExponential();
return signString + freeFormat();
}
private String freeFormatExponential() {
// corresponds to process "Free-Format Exponential"
char[] formattedDecimal = new char[25];
formattedDecimal[0] = (char) ('0' + uArray[getCount++]);
formattedDecimal[1] = '.';
// the position the next character is to be inserted into
// formattedDecimal
int charPos = 2;
int k = firstK;
int expt = k;
while (true) {
k--;
if (getCount >= setCount)
break;
formattedDecimal[charPos++] = (char) ('0' + uArray[getCount++]);
}
if (k == expt - 1)
formattedDecimal[charPos++] = '0';
formattedDecimal[charPos++] = 'E';
return new String(formattedDecimal, 0, charPos)
+ Integer.toString(expt);
}
private String freeFormat() {
// corresponds to process "Free-Format"
char[] formattedDecimal = new char[25];
// the position the next character is to be inserted into
// formattedDecimal
int charPos = 0;
int k = firstK;
if (k < 0) {
formattedDecimal[0] = '0';
formattedDecimal[1] = '.';
charPos += 2;
for (int i = k + 1; i < 0; i++)
formattedDecimal[charPos++] = '0';
}
int U = uArray[getCount++];
do {
if (U != -1)
formattedDecimal[charPos++] = (char) ('0' + U);
else if (k >= -1)
formattedDecimal[charPos++] = '0';
if (k == 0)
formattedDecimal[charPos++] = '.';
k--;
U = getCount < setCount ? uArray[getCount++] : -1;
} while (U != -1 || k >= -1);
return new String(formattedDecimal, 0, charPos);
}
private native void bigIntDigitGeneratorInstImpl(long f, int e,
boolean isDenormalized, boolean mantissaIsZero, int p);
private void longDigitGenerator(long f, int e, boolean isDenormalized,
boolean mantissaIsZero, int p) {
long R, S, M;
if (e >= 0) {
M = 1l << e;
if (!mantissaIsZero) {
R = f << (e + 1);
S = 2;
} else {
R = f << (e + 2);
S = 4;
}
} else {
M = 1;
if (isDenormalized || !mantissaIsZero) {
R = f << 1;
S = 1l << (1 - e);
} else {
R = f << 2;
S = 1l << (2 - e);
}
}
int k = (int) Math.ceil((e + p - 1) * invLogOfTenBaseTwo - 1e-10);
if (k > 0) {
S = S * TEN_TO_THE[k];
} else if (k < 0) {
long scale = TEN_TO_THE[-k];
R = R * scale;
M = M == 1 ? scale : M * scale;
}
if (R + M > S) { // was M_plus
firstK = k;
} else {
firstK = k - 1;
R = R * 10;
M = M * 10;
}
getCount = setCount = 0; // reset indices
boolean low, high;
int U;
long[] Si = new long[] { S, S << 1, S << 2, S << 3 };
while (true) {
// set U to be floor (R / S) and R to be the remainder
// using a kind of "binary search" to find the answer.
// It's a lot quicker than actually dividing since we know
// the answer will be between 0 and 10
U = 0;
long remainder;
for (int i = 3; i >= 0; i--) {
remainder = R - Si[i];
if (remainder >= 0) {
R = remainder;
U += 1 << i;
}
}
low = R < M; // was M_minus
high = R + M > S; // was M_plus
if (low || high)
break;
R = R * 10;
M = M * 10;
uArray[setCount++] = U;
}
if (low && !high)
uArray[setCount++] = U;
else if (high && !low)
uArray[setCount++] = U + 1;
else if ((R << 1) < S)
uArray[setCount++] = U;
else
uArray[setCount++] = U + 1;
}
}