Numeric.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <errno.h>      // errno
#include <float.h>      // FLT_MIN, FLT_MAX
#include <math.h>       // modf, HUGE_VAL
#include <wctype.h>     // iswspace
#include <wchar.h>      // wcstol, wcstoul
 
#include <dcl/_stdlib.h>
 
#include <dcl/Object.h>
#include <dcl/Numeric.h>
#include "__xtoa.h"
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/Numeric.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
#if 0
static void formatHelper(String& strResult,
    const String& strNumber, 
    const String& strFormat,
    bool bThousandsSep /* = */
)
{
    if (strFormat.isEmpty()) {
        strResult += strNumber;
        return;
    }
 
    int nNumber = strNumber.length();
    int nFormat = strFormat.length();
    const char* psz = strNumber.cstr();
    const char* pszFormat = strFormat.cstr();
    if (/* *psz != '\0' && */ *psz == '-') {
        strResult += *psz;
        psz++;
        nNumber--;
    }
    if (*pszFormat != '\0' && *pszFormat != '#' && *pszFormat != '0') {
        // currency symbol
        strResult += *pszFormat;
        pszFormat++;
        nFormat--;
    }
 
    int nGreateFormat = nFormat - nNumber;
    if (nGreateFormat > 0) {
        int nThousandsPos = nFormat % 3;
        int i = 0;
        bool bEmpty = true;
        for (; nGreateFormat--; i++) {
            if (*pszFormat == '0') {
                if (!bEmpty && bThousandsSep && ((i % 3) == nThousandsPos))
                    strResult += ',';
 
                strResult += '0';
                bEmpty = false;
            }
            else if (*pszFormat == '#') {
                if (!bEmpty && bThousandsSep && ((i % 3) == nThousandsPos))
                {
                    strResult += ',';
                }
            }
            pszFormat++;
        }
 
        for(; *psz ; i++) {
            if (!bEmpty && bThousandsSep && ((i % 3) == nThousandsPos))
                strResult += ',';
            strResult += *psz++;
            bEmpty = false;
        }
    }
    else {
        int nThousandsPos = nNumber % 3;
        for(int i = 0; *psz ; i++) {
            if (i != 0 && bThousandsSep && ((i % 3) == nThousandsPos))
                strResult += ',';
            strResult += *psz++;
        }
    }
}
 
String formatDouble(double _value, const char* pszFormat)
{
    __DCL_ASSERT(pszFormat != NULL);
    String strFormat = pszFormat;
    String strResult;
    // 유효숫자리 계산
 
    int nDigit = 17;
    int nDecimalPoint = 0;
    int nSign = 0;
 
    char szBuf[_CVTBUFSIZE];
    __DCL_VERIFY(_ecvt_s(szBuf, sizeof(szBuf), _value, nDigit, &nDecimalPoint, &nSign) == 0);
 
    if (nDecimalPoint <= 0)
        nDigit = 0;
    else
        nDigit = nDecimalPoint;
 
    int nFormatDecimalPoint = strFormat.find('.');
    if (nFormatDecimalPoint >= 0)
        nDigit += strFormat.length() - nFormatDecimalPoint - 1;
 
    if (nDigit > 17)    // double precision
        nDigit = 17;
 
    __DCL_VERIFY(_ecvt_s(szBuf, sizeof(szBuf), _value, nDigit, &nDecimalPoint, &nSign) == 0);
    String strDouble = szBuf;
 
    if (nDecimalPoint < 0) {
        String strZero('0', abs(nDecimalPoint));
        strDouble.insert(0, strZero);
        strDouble.setLength(nDigit);
        nDecimalPoint = 0;
    }
    else {
        if (nDigit < nDecimalPoint)
            strDouble.append('0', nDecimalPoint - nDigit);
    }
 
    // 여기서부터는 문자열 처리
    String strInt(strDouble, 0, nDecimalPoint);
    String strDecimal(strDouble, nDecimalPoint, strDouble.length() - nDecimalPoint);
 
    if (nSign)
        strResult = '-';
 
    if (!strDecimal.isEmpty() && strInt.isEmpty())
        strInt = "0";
 
    String strIntFormat;
    String strDecimalFormat;
 
    strIntFormat.assign(strFormat, 0, nFormatDecimalPoint);
    strDecimalFormat.assign(strFormat, 
        nFormatDecimalPoint + 1, strFormat.length() - nFormatDecimalPoint - 1);
 
    formatHelper(strResult, strInt, strIntFormat, (int)strFormat.find(',') >= 0);
 
    // 소수부분의 마지막 부분부터 '0' 인 문자를 삭제한다.
    strDecimal.trimRight('0');
 
    // 소수부분이 비어있지 않으면..
    if (!strDecimal.isEmpty() || nFormatDecimalPoint >= 0) {
        if (!(strDecimal.isEmpty() 
            && !strDecimalFormat.isEmpty() 
            && strDecimalFormat.at(0) == '#')
        ) {
            strResult += '.';
            formatHelper(strResult, strDecimal, strDecimalFormat, false);
        }
    }
    return strResult;
}
 
// 이 함수는 소수점 아래에 대하여 포멧을 수행하지 않는다.
// 이 함수를 호출하기전에 반드시 precision을 정해야 한다.
// 가급적 이 함수를 호출하지 말것 .. Oracle NUMBER 의 경우 사용하기 위함.
String formatDecimalString(const String& strNumber, const char* pszFormat)
{
    __DCL_ASSERT(pszFormat != NULL);
 
    String strFormat = pszFormat;
    String strResult;
 
    int nDecimalPoint = strNumber.find('.');
    int nFormatDecimalPoint = strFormat.find('.');
 
    String strInt;
    String strIntFormat;
 
    if (nDecimalPoint >= 0)
        strInt.assign(strNumber, 0, nDecimalPoint);
    else
        strInt = strNumber;
 
    if (nFormatDecimalPoint >= 0)
        strIntFormat.assign(strFormat, 0, nFormatDecimalPoint);
    else
        strIntFormat = strFormat;
 
    formatHelper(strResult, strInt, strIntFormat, (int)strFormat.find(',') >= 0);
 
    // 소수부분이 비어있지 않으면..
    // 소부부분의 포멧팅을 수행하지 않는다 단지 복사한다.
    if (nDecimalPoint >= 0 && (int)strNumber.length() > nDecimalPoint + 1) {
        strResult.append(strNumber, nDecimalPoint, strNumber.length() - nDecimalPoint);
    }
 
    return strResult;
}
 
String formatIntegerString(const char* pszIntegerValue, const char* pszFormat)
{
    __DCL_ASSERT(pszIntegerValue != NULL);
    __DCL_ASSERT(pszFormat != NULL);
 
    String strInt = pszIntegerValue;
    String strFormat = pszFormat;
    String strResult;
 
    if (strInt == "0")
        strInt.clear();
 
    String strIntFormat;
    String strDecimalFormat;
    int nFormatDecimalPoint = strFormat.find('.');
    if (nFormatDecimalPoint >= 0) {
        strIntFormat.assign(strFormat, 0, nFormatDecimalPoint);
        strDecimalFormat.assign(strFormat, 
            nFormatDecimalPoint + 1, strFormat.length() - nFormatDecimalPoint - 1);
    }
    else
        strIntFormat = strFormat;
 
    formatHelper(strResult, strInt, strIntFormat, (int)strFormat.find(',') >= 0);
    if (!strDecimalFormat.isEmpty() && strDecimalFormat.at(0) == '0') {
        strResult += '.';
        formatHelper(strResult, "", strDecimalFormat, false);
    }
    return strResult;
}
#endif


 
String Int32::toString(int32_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    CharBuffer* buf = CharBuffer::create(40);
    __int32tow(_n, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String Int32::toString(int32_t _n, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%ld");
 
    __DCL_ASSERT_PARAM(*_format != '\0');
 
    return String::format(_format, _n);
}
 
int32_t Int32::parse(const wchar_t* _number, unsigned _base)
    __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    long n = wcstol(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (LONG_MIN == n) {
            error = NumericConvertException::Underflow;
        }
        else if (LONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
#if __WORDSIZE > 32
        else if (n < INT32_MIN) {
            error = NumericConvertException::Underflow;
        }
        else if (INT32_MAX < n) {
            error = NumericConvertException::Overflow;
        }
#endif
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            _base
        );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
        );
    }
 
    return (int32_t)n;
}
 
int32_t Int32::parse(const wchar_t* _number, unsigned _base, int32_t _default)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    long n = wcstol(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (LONG_MIN == n) {
            error = NumericConvertException::Underflow;
        }
        else if (LONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
#if __WORDSIZE > 32
        else if (n < INT32_MIN) {
            error = NumericConvertException::Underflow;
        }
        else if (INT32_MAX < n) {
            error = NumericConvertException::Overflow;
        }
#endif
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (int32_t)n;
}
 
ByteString Int32::toByteString(int32_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(40);
    __int32toa(_n, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}

 
String UInt32::toString(uint32_t _u, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    CharBuffer* buf = CharBuffer::create(40);
    __uint32tow(_u, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String UInt32::toString(uint32_t _u, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%lu");
 
    __DCL_ASSERT_PARAM(*_format != '\0');
 
    return String::format(_format, _u);
}
 
uint32_t UInt32::parse(const wchar_t* _number, unsigned _base)
    __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    unsigned long n = wcstoul(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (ULONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
#if __WORDSIZE > 32
        else if (UINT32_MAX < n) {
            error = NumericConvertException::Overflow;
        }
#endif
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            _base
        );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
        );
    }
 
    return (uint32_t) n;
}
 
uint32_t UInt32::parse(const wchar_t* _number, unsigned _base, uint32_t _default)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    unsigned long n = wcstoul(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (ULONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
#if __WORDSIZE > 32
        else if (UINT32_MAX < n) {
            error = NumericConvertException::Overflow;
        }
#endif
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (uint32_t) n;
}
 
ByteString UInt32::toByteString(uint32_t _u, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(40);
    __uint32toa(_u, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}

 
String Int64::toString(int64_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
     // 2진수일경우 64 + sign = 65
    CharBuffer* buf = CharBuffer::create(70);
    __int64tow(_n, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String Int64::toString(int64_t _n, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%lld");
 
    __DCL_ASSERT_PARAM(*_format != '\0');
 
    return String::format(_format, _n);
}
 
#ifdef __WINNT__
#define wcstoll(nptr, endptr, base) _wcstoi64(nptr, endptr, base)
#define wcstoull(nptr, endptr, base) _wcstoui64(nptr, endptr, base)
#endif
 
int64_t Int64::parse(const wchar_t* _number, unsigned _base)
    __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    long long n = wcstoll(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (LLONG_MIN == n) {
            error = NumericConvertException::Underflow;
        }
        else if (LLONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
 
        if (NumericConvertException::NoError != error) {
            throw new NumericConvertException(
                error,
                _number,
                _base
            );
        }
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
        );
    }
 
    return (int64_t) n;
}
 
int64_t Int64::parse(const wchar_t* _number, unsigned _base, int64_t _default)
    __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    long long n = wcstoll(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (LLONG_MIN == n) {
            error = NumericConvertException::Underflow;
        }
        else if (LLONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (int64_t) n;
}
 
ByteString Int64::toByteString(int64_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(70);
    __int64toa(_n, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}

 
String UInt64::toString(uint64_t _u, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
     // 2진수일경우 64 + sign = 65
    CharBuffer* buf = CharBuffer::create(70);
    __uint64tow(_u, buf->data(), _base);
    buf->__dataLength = String::length(buf->data());
    String s(buf);
    buf->release();
    return s;
}
 
String UInt64::toString(uint64_t _u, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%ull");
 
    __DCL_ASSERT(*_format != '\0');
 
    return String::format(_format, _u);
}
 
uint64_t UInt64::parse(const wchar_t* _number, unsigned _base)
    __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, _base, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    unsigned long long n = wcstoull(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (ULLONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            _base
            );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            _base,
            endptr ? (endptr - _number) : 0
        );
    }
 
    return (uint64_t) n;
}
 
uint64_t UInt64::parse(const wchar_t* _number, unsigned _base, uint64_t _default)
{
    __DCL_ASSERT(_number != NULL);
    __DCL_ASSERT(_base > 1);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    unsigned long long n = wcstoull(_number, &endptr, _base);
    if (errno == ERANGE) {
        if (ULONG_MAX == n) {
            error = NumericConvertException::Overflow;
        }
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (uint64_t) n;
}
 
ByteString UInt64::toByteString(uint64_t _n, unsigned _base)
{
    __DCL_ASSERT_PARAM(2 <= _base && _base <= 32);
    // 2진수일경우 32 + sign = 33
    ByteBuffer* buf = ByteBuffer::create(70);
    __uint64toa(_n, buf->data(), _base);
    buf->__dataLength = ByteString::length(buf->data());
    ByteString s(buf);
    buf->release();
    return s;
}
 
// Lengths of Exponents and Mantissas
// Type     |Exponent length    |Mantissa length    |   문자열 길이
//          |                   |                   | 가수    | 지수
//--------------------------------------------------------------------------------
// float    |   8 bits          |   23 bits         |   3   |   7
// double   |   11 bits         |   52 bits         |   4   |   15
// 
 
//Range of Floating-Point Types
//Type      |   Minimum value               |   Maximum value 
//--------------------------------------------------------------------------------
//float     |   1.175494351 E - 38          |   3.402823466 E + 38 
//double    |   2.2250738585072014 E - 308  |   1.7976931348623158 E + 308 

#if 0
String Single::toString(float _f)
{
    String s;
    char* psz = s.getBuffer(_CVTBUFSIZE);   // 9 + '.' + 'E' + '-' + 3 ==> 15
    _gcvt_s(psz, _CVTBUFSIZE, f, 8);
    s.releaseBuffer();
    return s;
}
#endif
 
String Single::toString(float _f, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%.8g");
 
    __DCL_ASSERT(*_format != '\0');
 
    return String::format(_format, _f);
}
 
float Single::parse(const wchar_t* _number)
    __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, 0, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    float n = wcstof(_number, &endptr);
    if (errno == ERANGE) {
        if (+HUGE_VALF == n || -HUGE_VALF == n) {
            error = NumericConvertException::Overflow;
        }
        else if (!(FLT_MIN < n)) {
            error = NumericConvertException::Underflow;
        }
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            0
        );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            0,
            endptr ? (endptr - _number) : 0
        );
    }
 
    return (float) n;
}
 
float Single::parse(const wchar_t* _number, float _default)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    float n = wcstof(_number, &endptr);
    if (errno == ERANGE) {
        if (+HUGE_VALF == n || -HUGE_VALF == n) {
            error = NumericConvertException::Overflow;
        }
        else if (!(FLT_MIN < n)) {
            error = NumericConvertException::Underflow;
        }
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (float) n;
}
 
ByteString Single::toByteString(float _f, const char* _format)
{
    if (!_format)
        _format = "%.8g";
 
    __DCL_ASSERT(*_format != '\0');
 
    return ByteString::format(_format, _f);
}

 
#if 0
String Double::toString(double _d)
{
    String s;
    char* psz = s.getBuffer(_CVTBUFSIZE);   // 17 + '.' + 'E' + '-' + 3 ==> 23
    _gcvt_s(psz, _CVTBUFSIZE, _value, 16);
    s.releaseBuffer();
    return s;
}
#endif
 
String Double::toString(double _d, const wchar_t* _format)
{
    if (!_format)
        _format = __T("%.16g");
 
    __DCL_ASSERT(*_format != '\0');
 
    return String::format(_format, _d);
}
 
double Double::parse(const wchar_t* _number)
    __DCL_THROWS1(NumericConvertException*)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        throw new NumericConvertException(_number, 0, 0);
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    double n = wcstod(_number, &endptr);
    if (errno == ERANGE) {
        if (+HUGE_VAL == n || -HUGE_VAL == n) {
            error = NumericConvertException::Overflow;
        }
        else if (!(DBL_MIN < n)) {
            error = NumericConvertException::Underflow;
        }
    }
 
    if (NumericConvertException::NoError != error) {
        throw new NumericConvertException(
            error,
            _number,
            0
        );
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        throw new NumericConvertException(
            _number,
            0,
            endptr ? (endptr - _number) : 0
        );
    }
 
    return (double) n;
}
 
double Double::parse(const wchar_t* _number, double _default)
{
    __DCL_ASSERT(_number != NULL);
 
    if (*_number == __T('\0') || iswspace((wint_t)*_number)) {
        return _default;
    }
 
    NumericConvertException::Error error = NumericConvertException::NoError;
    errno = 0;
    wchar_t* endptr = NULL;
    double n = wcstod(_number, &endptr);
    if (errno == ERANGE) {
        if (+HUGE_VAL == n || -HUGE_VAL == n) {
            error = NumericConvertException::Overflow;
        }
        else if (!(DBL_MIN < n)) {
            error = NumericConvertException::Underflow;
        }
    }
 
    if (NumericConvertException::NoError != error) {
        return _default;
    }
 
    if ((endptr && *endptr != '\0') || errno == EINVAL) {
        return _default;
    }
 
    return (double) n;
}
 
ByteString Double::toByteString(double _d, const char* _format)
{
    if (!_format)
        _format = "%.16g";
 
    __DCL_ASSERT(*_format != '\0');
 
    return ByteString::format(_format, _d);
}

 
const char* Decimal::FORMAT_STRING = "#,###.####";
 
static String __GetDecimalString(double d)
{
#if 0
    int nDigit = 16;    // double procision
    int nDecimalPoint = 0;
    int nSign = 0;
    char* psz = NULL;
 
    char szBuf[_CVTBUFSIZE];    // buf[22];
    __DCL_VERIFY(_ecvt_s(szBuf, sizeof(szBuf), d, nDigit, &nDecimalPoint, &nSign) == 0);
 
    psz = szBuf;
    char* p = psz + nDigit;
    while(psz <= --p) {
        if (*p != '0')
            break;
    }
 
    *(++p) = '\0';
 
    int nLen = p - psz;
 
    String str;
    if (nLen > 0) {
        if (nSign)
            str = '-';
 
        if (nDecimalPoint < 0) {
            str += "0.";
            str.append('0', -nDecimalPoint);
            str += psz;
        }
        else {
            if (nDecimalPoint >= nLen) {
                str.append(psz);
                if (nDecimalPoint > nLen)
                    str.append('0', nDecimalPoint - nLen);
                str.append(".0");
            }
            else {
                str.append(psz, nDecimalPoint);
                str.append('.');
                str.append(psz + nDecimalPoint);
            }
        }
    }
    else
        str = "0.0";
 
    return str;
#endif
    return String();
}
 
const Decimal& Decimal::operator = (float _value)
{
    __value = __GetDecimalString(_value);
    return *this;
}
 
const Decimal& Decimal::operator = (double _value)
{
    __value = __GetDecimalString(_value);
    return *this;
}
 
String Decimal::toStringF(const Decimal& _value, 
    const char* pszDecimalFormat // = NULL
)
{
#if 0
    if (!pszDecimalFormat)
        pszDecimalFormat = FORMAT_STRING;
 
    __DCL_ASSERT(*pszDecimalFormat != '\0');
 
    return formatDecimalString(
        _value.__value, 
        pszDecimalFormat
    );
#endif
    return String();
}
 
/*
int32_t Decimal::toInt32() const
{
    return atoi(__value);
}
 
int64_t Decimal::toInt64() const
{
#ifdef __WINNT__
    return _atoi64(__value);
#else
    return atoll(__value);
#endif
}
 
double Decimal::toDouble() const
{
    return atof(__value);
}
*/
 
__DCL_END_NAMESPACE