modules/luni/src/main/java/org/apache/harmony/luni/util/NumberConverter.java - harmony-classlib - 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.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;
 	}
 }
	/*
	* 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;
	}
	}