577 lines
18 KiB
C++
577 lines
18 KiB
C++
/*
|
|
**********************************************************************
|
|
* Copyright (C) 1997-1999, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
**********************************************************************
|
|
*
|
|
* File DIGITLST.CPP
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 03/21/97 clhuang Converted from java.
|
|
* 03/21/97 clhuang Implemented with new APIs.
|
|
* 03/27/97 helena Updated to pass the simple test after code review.
|
|
* 03/31/97 aliu Moved isLONG_MIN to here, and fixed it.
|
|
* 04/15/97 aliu Changed MAX_COUNT to DBL_DIG. Changed Digit to char.
|
|
* Reworked representation by replacing fDecimalAt with
|
|
* fExponent.
|
|
* 04/16/97 aliu Rewrote set() and getDouble() to use sprintf/atof
|
|
* to do digit conversion.
|
|
* 09/09/97 aliu Modified for exponential notation support.
|
|
* 08/02/98 stephen Added nearest/even rounding
|
|
* Fixed bug in fitsIntoLong
|
|
********************************************************************************
|
|
*/
|
|
|
|
#include "digitlst.h"
|
|
#include <stdlib.h>
|
|
#include <limits.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include "unicode/putil.h"
|
|
|
|
// *****************************************************************************
|
|
// class DigitList
|
|
// This class handles the transcoding between numeric values and strings of
|
|
// characters. Only handles as non-negative numbers.
|
|
// *****************************************************************************
|
|
|
|
const char DigitList::kZero = '0';
|
|
|
|
/* Only for 32 bit numbers. Ignore the negative sign. */
|
|
static const char LONG_MIN_REP[] = "2147483648";
|
|
|
|
enum {
|
|
LONG_MIN_REP_LENGTH = sizeof(LONG_MIN_REP) - 1 //Ignore the NULL at the end
|
|
};
|
|
|
|
// -------------------------------------
|
|
// default constructor
|
|
|
|
DigitList::DigitList()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
DigitList::~DigitList()
|
|
{
|
|
}
|
|
|
|
// -------------------------------------
|
|
// copy constructor
|
|
|
|
DigitList::DigitList(const DigitList &other)
|
|
{
|
|
fDigits = fDecimalDigits + 1; // skip the decimal
|
|
*this = other;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// assignment operator
|
|
|
|
DigitList&
|
|
DigitList::operator=(const DigitList& other)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
fDecimalAt = other.fDecimalAt;
|
|
fCount = other.fCount;
|
|
strncpy(fDigits, other.fDigits, MAX_DIGITS);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UBool
|
|
DigitList::operator==(const DigitList& that) const
|
|
{
|
|
return ((this == &that) ||
|
|
(fDecimalAt == that.fDecimalAt &&
|
|
fCount == that.fCount &&
|
|
0 == strncmp(fDigits, that.fDigits, fCount)));
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Resets the digit list; sets all the digits to zero.
|
|
|
|
void
|
|
DigitList::clear()
|
|
{
|
|
fDigits = fDecimalDigits + 1; // skip the decimal
|
|
fDecimalAt = 0;
|
|
fCount = 0;
|
|
fIsPositive = TRUE;
|
|
|
|
// Don't bother initializing fDigits because fCount is 0.
|
|
}
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
int32_t
|
|
DigitList::formatBase10(int32_t number, char *outputStr, int32_t outputLen)
|
|
{
|
|
char buffer[MAX_DIGITS + 1];
|
|
int32_t bufferLen;
|
|
|
|
if (outputLen > MAX_DIGITS) {
|
|
outputLen = MAX_DIGITS; // Ignore NULL
|
|
}
|
|
else if (outputLen < 3) {
|
|
return 0; // Not enough room
|
|
}
|
|
|
|
bufferLen = outputLen;
|
|
|
|
if (number < 0) { // Negative numbers are slightly larger than a postive
|
|
buffer[bufferLen--] = (char)(-(number % 10) + '0');
|
|
number /= -10;
|
|
*(outputStr++) = '-';
|
|
}
|
|
else {
|
|
*(outputStr++) = '+'; // allow +0
|
|
}
|
|
while (bufferLen >= 0 && number) { // Output the number
|
|
buffer[bufferLen--] = (char)(number % 10 + '0');
|
|
number /= 10;
|
|
}
|
|
|
|
outputLen -= bufferLen++;
|
|
|
|
while (bufferLen <= MAX_DIGITS) { // Copy the number to output
|
|
*(outputStr++) = buffer[bufferLen++];
|
|
}
|
|
*outputStr = 0; // NULL terminate.
|
|
return outputLen;
|
|
}
|
|
|
|
/**
|
|
* Currently, getDouble() depends on atof() to do its conversion.
|
|
*
|
|
* WARNING!!
|
|
* This is an extremely costly function. ~1/2 of the conversion time
|
|
* can be linked to this function.
|
|
*/
|
|
double
|
|
DigitList::getDouble()
|
|
{
|
|
double value;
|
|
|
|
if (fCount == 0) {
|
|
value = 0.0;
|
|
}
|
|
else {
|
|
*fDecimalDigits = '.';
|
|
*(fDigits+fCount) = 'e'; // add an e after the digits.
|
|
formatBase10(fDecimalAt,
|
|
fDigits + fCount + 1, // skip the 'e'
|
|
MAX_DEC_DIGITS - fCount - 3); // skip the 'e' and '.'
|
|
value = atof(fDecimalDigits);
|
|
}
|
|
|
|
return fIsPositive ? value : -value;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
/**
|
|
* Make sure that fitsIntoLong() is called before calling this function.
|
|
*/
|
|
int32_t DigitList::getLong()
|
|
{
|
|
if (fCount == fDecimalAt) {
|
|
int32_t value;
|
|
|
|
fDigits[fCount] = 0; // NULL terminate
|
|
|
|
// This conversion is bad on 64-bit platforms when we want to
|
|
// be able to return a 64-bit number [grhoten]
|
|
*fDecimalDigits = fIsPositive ? '+' : '-';
|
|
value = (int32_t)atol(fDecimalDigits);
|
|
return value;
|
|
}
|
|
else {
|
|
// This is 100% accurate in c++ because if we are representing
|
|
// an integral value, we suffer nothing in the conversion to
|
|
// double. If we are to support 64-bit longs later, getLong()
|
|
// must be rewritten. [LIU]
|
|
return (int32_t)getDouble();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the number represented by this object can fit into
|
|
* a long.
|
|
*/
|
|
UBool
|
|
DigitList::fitsIntoLong(UBool ignoreNegativeZero)
|
|
{
|
|
// Figure out if the result will fit in a long. We have to
|
|
// first look for nonzero digits after the decimal point;
|
|
// then check the size. If the digit count is 18 or less, then
|
|
// the value can definitely be represented as a long. If it is 19
|
|
// then it may be too large.
|
|
|
|
// Trim trailing zeros after the decimal point. This does not change
|
|
// the represented value.
|
|
while (fCount > fDecimalAt && fCount > 0 && fDigits[fCount - 1] == '0')
|
|
--fCount;
|
|
|
|
if (fCount == 0) {
|
|
// Positive zero fits into a long, but negative zero can only
|
|
// be represented as a double. - bug 4162852
|
|
return fIsPositive || ignoreNegativeZero;
|
|
}
|
|
|
|
// initializeLONG_MIN_REP();
|
|
|
|
// If the digit list represents a double or this number is too
|
|
// big for a long.
|
|
if (fDecimalAt < fCount || fDecimalAt > LONG_MIN_REP_LENGTH)
|
|
return FALSE;
|
|
|
|
// If number is small enough to fit in a long
|
|
if (fDecimalAt < LONG_MIN_REP_LENGTH)
|
|
return TRUE;
|
|
|
|
// At this point we have fDecimalAt == fCount, and fCount == LONG_MIN_REP_LENGTH.
|
|
// The number will overflow if it is larger than LONG_MAX
|
|
// or smaller than LONG_MIN.
|
|
for (int32_t i=0; i<fCount; ++i)
|
|
{
|
|
char dig = fDigits[i],
|
|
max = LONG_MIN_REP[i];
|
|
if (dig > max)
|
|
return FALSE;
|
|
if (dig < max)
|
|
return TRUE;
|
|
}
|
|
|
|
// At this point the first count digits match. If fDecimalAt is less
|
|
// than count, then the remaining digits are zero, and we return true.
|
|
if (fCount < fDecimalAt)
|
|
return TRUE;
|
|
|
|
// Now we have a representation of Long.MIN_VALUE, without the leading
|
|
// negative sign. If this represents a positive value, then it does
|
|
// not fit; otherwise it fits.
|
|
return !fIsPositive;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
/**
|
|
* @param maximumDigits The maximum digits to be generated. If zero,
|
|
* there is no maximum -- generate all digits.
|
|
*/
|
|
void
|
|
DigitList::set(int32_t source, int32_t maximumDigits)
|
|
{
|
|
fCount = fDecimalAt = formatBase10(source, fDecimalDigits, MAX_DIGITS);
|
|
|
|
fIsPositive = (*fDecimalDigits == '+');
|
|
|
|
// Don't copy trailing zeros
|
|
while (fCount > 1 && fDigits[fCount - 1] == '0')
|
|
--fCount;
|
|
|
|
if(maximumDigits > 0)
|
|
round(maximumDigits);
|
|
}
|
|
|
|
/**
|
|
* Set the digit list to a representation of the given double value.
|
|
* This method supports both fixed-point and exponential notation.
|
|
* @param source Value to be converted; must not be Inf, -Inf, Nan,
|
|
* or a value <= 0.
|
|
* @param maximumDigits The most fractional or total digits which should
|
|
* be converted. If total digits, and the value is zero, then
|
|
* there is no maximum -- generate all digits.
|
|
* @param fixedPoint If true, then maximumDigits is the maximum
|
|
* fractional digits to be converted. If false, total digits.
|
|
*/
|
|
void
|
|
DigitList::set(double source, int32_t maximumDigits, UBool fixedPoint)
|
|
{
|
|
// for now, simple implementation; later, do proper IEEE stuff
|
|
char rep[MAX_DIGITS + 8]; // Extra space for '+', '.', e+NNN, and '\0' (actually +8 is enough)
|
|
char *digitPtr = fDigits;
|
|
char *repPtr = rep + 2; // +2 to skip the sign and decimal
|
|
int32_t exponent = 0;
|
|
|
|
fIsPositive = !uprv_isNegative(source); // Allow +0 and -0
|
|
|
|
// Generate a representation of the form /[+-][0-9]+e[+-][0-9]+/
|
|
sprintf(rep, "%+1.*e", MAX_DIGITS - 1, source);
|
|
fDecimalAt = 0;
|
|
rep[2] = rep[1]; // remove decimal
|
|
|
|
while (*repPtr == '0') {
|
|
repPtr++;
|
|
fDecimalAt--; // account for leading zeros
|
|
}
|
|
|
|
while (*repPtr != 'e') {
|
|
*(digitPtr++) = *(repPtr++);
|
|
}
|
|
fCount = MAX_DIGITS + fDecimalAt;
|
|
|
|
// Parse an exponent of the form /[eE][+-][0-9]+/
|
|
UBool negExp = (*(++repPtr) == '-');
|
|
while (*(++repPtr) != 0) {
|
|
exponent = 10*exponent + *repPtr - '0';
|
|
}
|
|
if (negExp) {
|
|
exponent = -exponent;
|
|
}
|
|
fDecimalAt += exponent + 1; // +1 for decimal removal
|
|
|
|
// The negative of the exponent represents the number of leading
|
|
// zeros between the decimal and the first non-zero digit, for
|
|
// a value < 0.1 (e.g., for 0.00123, -decimalAt == 2). If this
|
|
// is more than the maximum fraction digits, then we have an underflow
|
|
// for the printed representation.
|
|
if (fixedPoint && -fDecimalAt >= maximumDigits)
|
|
{
|
|
// If we round 0.0009 to 3 fractional digits, then we have to
|
|
// create a new one digit in the least significant location.
|
|
if (-fDecimalAt == maximumDigits && shouldRoundUp(0)) {
|
|
fCount = 1;
|
|
++fDecimalAt;
|
|
fDigits[0] = (char)'1';
|
|
} else {
|
|
// Handle an underflow to zero when we round something like
|
|
// 0.0009 to 2 fractional digits.
|
|
fCount = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// Eliminate digits beyond maximum digits to be displayed.
|
|
// Round up if appropriate. Do NOT round in the special
|
|
// case where maximumDigits == 0 and fixedPoint is FALSE.
|
|
if (fixedPoint || (0 < maximumDigits && maximumDigits < fCount)) {
|
|
round(fixedPoint ? (maximumDigits + fDecimalAt) : maximumDigits);
|
|
}
|
|
else {
|
|
// Eliminate trailing zeros.
|
|
while (fCount > 1 && fDigits[fCount - 1] == '0')
|
|
--fCount;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
/**
|
|
* Round the representation to the given number of digits.
|
|
* @param maximumDigits The maximum number of digits to be shown.
|
|
* Upon return, count will be less than or equal to maximumDigits.
|
|
*/
|
|
void
|
|
DigitList::round(int32_t maximumDigits)
|
|
{
|
|
// Eliminate digits beyond maximum digits to be displayed.
|
|
// Round up if appropriate.
|
|
/* if (maximumDigits >= 0 && maximumDigits < fCount)
|
|
{
|
|
if (shouldRoundUp(maximumDigits)) {
|
|
// Rounding up involved incrementing digits from LSD to MSD.
|
|
// In most cases this is simple, but in a worst case situation
|
|
// (9999..99) we have to adjust the decimalAt value.
|
|
for (;;)
|
|
{
|
|
--maximumDigits;
|
|
if (maximumDigits < 0)
|
|
{
|
|
// We have all 9's, so we increment to a single digit
|
|
// of one and adjust the exponent.
|
|
fDigits[0] = (char) '1';
|
|
++fDecimalAt;
|
|
maximumDigits = 0; // Adjust the count
|
|
break;
|
|
}
|
|
|
|
++fDigits[maximumDigits];
|
|
if (fDigits[maximumDigits] <= '9')
|
|
break;
|
|
// fDigits[maximumDigits] = '0'; // Unnecessary since we'll truncate this
|
|
}
|
|
++maximumDigits; // Increment for use as count
|
|
}
|
|
fCount = maximumDigits;
|
|
|
|
// Eliminate trailing zeros.
|
|
while (fCount > 1 && fDigits[fCount-1] == '0') {
|
|
--fCount;
|
|
}
|
|
}*/
|
|
// Eliminate digits beyond maximum digits to be displayed.
|
|
// Round up if appropriate.
|
|
if (maximumDigits >= 0 && maximumDigits < fCount)
|
|
{
|
|
if (shouldRoundUp(maximumDigits)) {
|
|
// Rounding up involved incrementing digits from LSD to MSD.
|
|
// In most cases this is simple, but in a worst case situation
|
|
// (9999..99) we have to adjust the decimalAt value.
|
|
while (--maximumDigits >= 0 && ++fDigits[maximumDigits] > '9')
|
|
;
|
|
|
|
if (maximumDigits < 0)
|
|
{
|
|
// We have all 9's, so we increment to a single digit
|
|
// of one and adjust the exponent.
|
|
fDigits[0] = (char) '1';
|
|
++fDecimalAt;
|
|
maximumDigits = 1; // Adjust the count
|
|
}
|
|
else
|
|
{
|
|
++maximumDigits; // Increment for use as count
|
|
}
|
|
}
|
|
fCount = maximumDigits;
|
|
}
|
|
|
|
// Eliminate trailing zeros.
|
|
while (fCount > 1 && fDigits[fCount-1] == '0') {
|
|
--fCount;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if truncating the representation to the given number
|
|
* of digits will result in an increment to the last digit. This
|
|
* method implements half-even rounding, the default rounding mode.
|
|
* [bnf]
|
|
* @param maximumDigits the number of digits to keep, from 0 to
|
|
* <code>count-1</code>. If 0, then all digits are rounded away, and
|
|
* this method returns true if a one should be generated (e.g., formatting
|
|
* 0.09 with "#.#").
|
|
* @return true if digit <code>maximumDigits-1</code> should be
|
|
* incremented
|
|
*/
|
|
UBool DigitList::shouldRoundUp(int32_t maximumDigits) {
|
|
// Implement IEEE half-even rounding
|
|
if (fDigits[maximumDigits] == '5' ) {
|
|
for (int i=maximumDigits+1; i<fCount; ++i) {
|
|
if (fDigits[i] != '0') {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return maximumDigits > 0 && (fDigits[maximumDigits-1] % 2 != 0);
|
|
}
|
|
return (fDigits[maximumDigits] > '5');
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
// In the Java implementation, we need a separate set(long) because 64-bit longs
|
|
// have too much precision to fit into a 64-bit double. In C++, longs can just
|
|
// be passed to set(double) as long as they are 32 bits in size. We currently
|
|
// don't implement 64-bit longs in C++, although the code below would work for
|
|
// that with slight modifications. [LIU]
|
|
/*
|
|
void
|
|
DigitList::set(long source)
|
|
{
|
|
// handle the special case of zero using a standard exponent of 0.
|
|
// mathematically, the exponent can be any value.
|
|
if (source == 0)
|
|
{
|
|
fcount = 0;
|
|
fDecimalAt = 0;
|
|
return;
|
|
}
|
|
|
|
// we don't accept negative numbers, with the exception of long_min.
|
|
// long_min is treated specially by being represented as long_max+1,
|
|
// which is actually an impossible signed long value, so there is no
|
|
// ambiguity. we do this for convenience, so digitlist can easily
|
|
// represent the digits of a long.
|
|
bool islongmin = (source == long_min);
|
|
if (islongmin)
|
|
{
|
|
source = -(source + 1); // that is, long_max
|
|
islongmin = true;
|
|
}
|
|
sprintf(fdigits, "%d", source);
|
|
|
|
// now we need to compute the exponent. it's easy in this case; it's
|
|
// just the same as the count. e.g., 0.123 * 10^3 = 123.
|
|
fcount = strlen(fdigits);
|
|
fDecimalAt = fcount;
|
|
|
|
// here's how we represent long_max + 1. note that we always know
|
|
// that the last digit of long_max will not be 9, because long_max
|
|
// is of the form (2^n)-1.
|
|
if (islongmin)
|
|
++fdigits[fcount-1];
|
|
|
|
// finally, we trim off trailing zeros. we don't alter fDecimalAt,
|
|
// so this has no effect on the represented value. we know the first
|
|
// digit is non-zero (see code above), so we only have to check down
|
|
// to fdigits[1].
|
|
while (fcount > 1 && fdigits[fcount-1] == kzero)
|
|
--fcount;
|
|
}
|
|
*/
|
|
|
|
/**
|
|
* Return true if this object represents the value zero. Anything with
|
|
* no digits, or all zero digits, is zero, regardless of fDecimalAt.
|
|
*/
|
|
UBool
|
|
DigitList::isZero() const
|
|
{
|
|
for (int32_t i=0; i<fCount; ++i)
|
|
if (fDigits[i] != kZero)
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* We represent LONG_MIN internally as LONG_MAX + 1. This is actually an impossible
|
|
* value, for positive long integers, so we are safe in doing so.
|
|
*/
|
|
UBool
|
|
DigitList::isLONG_MIN() const
|
|
{
|
|
// initializeLONG_MIN_REP();
|
|
|
|
if (fCount != LONG_MIN_REP_LENGTH)
|
|
return FALSE;
|
|
|
|
for (int32_t i = 0; i < LONG_MIN_REP_LENGTH; ++i)
|
|
{
|
|
if (fDigits[i] != LONG_MIN_REP[i+1])
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Initialize the LONG_MIN representation buffer. Note that LONG_MIN
|
|
// is stored as LONG_MAX+1 (LONG_MIN without the negative sign).
|
|
|
|
/*void
|
|
DigitList::initializeLONG_MIN_REP()
|
|
{
|
|
if (LONG_MIN_REP_LENGTH == 0)
|
|
{
|
|
char buf[LONG_DIGITS];
|
|
sprintf(buf, "%d", INT32_MIN);
|
|
LONG_MIN_REP_LENGTH = strlen(buf) - 1;
|
|
// assert(LONG_MIN_REP_LENGTH == LONG_DIGITS);
|
|
for (int32_t i=1; i<=LONG_MIN_REP_LENGTH; ++i)
|
|
LONG_MIN_REP[i-1] = buf[i];
|
|
}
|
|
}*/
|
|
|
|
//eof
|