_RETURN_TYPE
INTERNAL_FUNCTION_NAME (DEC_TYPE x)
{
DEC_TYPE result;
decContext context;
decNumber dn_result;
decNumber dn_x;
decNumber dn_absx;
decNumber dn_logx;
decNumber dn_one;
decNumber dn_cmp;
enum rounding round;
FUNC_CONVERT_TO_DN (&x, &dn_x);
if (decNumberIsZero (&dn_x))
{
DFP_EXCEPT (FE_INVALID);
DFP_ERRNO (EDOM);
return _FBLOG0;
}
if (decNumberIsInfinite (&dn_x))
{
DFP_EXCEPT (FE_INVALID);
DFP_ERRNO (EDOM);
return decNumberIsNegative (&dn_x) ? _MIN_VALUE : _MAX_VALUE;
}
if (decNumberIsNaN (&dn_x))
{
DFP_EXCEPT (FE_INVALID);
DFP_ERRNO (EDOM);
return _FBLOGNAN;
}
decContextDefault (&context, DEFAULT_CONTEXT);
decNumberAbs (&dn_absx, &dn_x, &context);
/* For DFP, we use radix 10 instead of whatever FLT_RADIX happens to be */
decNumberLog10 (&dn_logx, &dn_absx, &context);
/* Capture the case where truncation will return the wrong result,
by rounding up if -1.0 < x < 1.0 */
round = DEC_ROUND_DOWN;
decNumberFromInt32 (&dn_one, 1);
decNumberCompare (&dn_cmp, &dn_x, &dn_one, &context);
if (-decNumberIsNegative(&dn_cmp))
{
decNumberFromInt32 (&dn_one, -1);
decNumberCompare (&dn_cmp, &dn_x, &dn_one, &context);
if (!decNumberIsNegative(&dn_cmp) && !decNumberIsZero(&dn_cmp))
round = DEC_ROUND_UP;
}
context.round = round;
decNumberToIntegralValue (&dn_result, &dn_logx, &context);
FUNC_CONVERT_FROM_DN (&dn_result, &result, &context);
/* Use _Decimal* to int casting. */
return (_RETURN_TYPE) result;
}
int DecimalDecNumber::comparedTo(const DecimalDecNumber &rhs) const
{
if (decNumberIsNaN(&m_value) || decNumberIsNaN(&rhs.m_value))
{
throw("Performing comparison on uninitialised decimal [Nan]");
}
// TODO: the commented out lines below do a strict comparison between two numbers.
// However, the unit tests assert that comparison should be done within a tolerance
//decNumberCompare(&result, &m_value, &rhs.m_value, &contextComparison);
//return decNumberToInt32(&result, &m_context);
decContext contextComparison;
decContextDefault(&contextComparison, DEC_INIT_BASE); // initialize
contextComparison.traps=0; // no traps, thank you
contextComparison.digits=DECNUMCOMPARISONDIGITS; // set precision
decNumber tmp(m_value);
decNumberSubtract(&tmp, &m_value, &rhs.m_value, &m_context);
decNumber result;
decNumberCompare(&result, &tmp, &comparisonThreshold.m_value, &contextComparison);
if (decNumberToInt32(&result, &m_context) >= 1)
{
return 1;
}
decNumberCompare(&result, &tmp, &comparisonThresholdNegative.m_value, &contextComparison);
if (decNumberToInt32(&result, &m_context) <= -1)
{
return -1;
}
return 0;
}
DEC_TYPE
INTERNAL_FUNCTION_NAME (DEC_TYPE x)
{
decContext context;
decNumber dn_result;
DEC_TYPE result;
decNumber dn_x;
decNumber dn_tmp;
decNumber dn_log10;
decNumber dn_one;
decNumber dn_cmp;
enum rounding round;
FUNC_CONVERT_TO_DN (&x, &dn_x);
if (decNumberIsNaN (&dn_x))
return x+x;
if (decNumberIsInfinite (&dn_x)) /* +-Inf: Inf */
return DEC_INFINITY;
if (decNumberIsZero (&dn_x)) /* Pole Error if x==0 */
{
DFP_ERRNO (ERANGE);
DFP_EXCEPT (FE_DIVBYZERO);
return -DFP_HUGE_VAL;
}
if (decNumberIsInfinite (&dn_x) && decNumberIsNegative (&dn_x))
return -x;
decContextDefault (&context, DEFAULT_CONTEXT);
decNumberAbs (&dn_tmp, &dn_x, &context);
/* For DFP, we use radix 10 instead of whatever FLT_RADIX
happens to be */
decNumberLog10 (&dn_log10, &dn_tmp, &context);
/* Capture the case where truncation will return the wrong result,
by rounding up if -1.0 < x < 1.0 */
round = DEC_ROUND_DOWN;
decNumberFromInt32 (&dn_one, 1);
decNumberCompare (&dn_cmp, &dn_x, &dn_one, &context);
if (-decNumberIsNegative(&dn_cmp))
{
decNumberFromInt32 (&dn_one, -1);
decNumberCompare (&dn_cmp, &dn_x, &dn_one, &context);
if (!decNumberIsNegative(&dn_cmp) && !decNumberIsZero(&dn_cmp))
round = DEC_ROUND_UP;
}
context.round = round;
decNumberToIntegralValue (&dn_result, &dn_log10, &context);
FUNC_CONVERT_FROM_DN (&dn_result, &result, &context);
return result;
}
void* decSingleCompare (decSingle* _0, const decSingle* _1, const decSingle* _2, decContext* ctx) noexcept
{
decNumber _0num;
decNumber _1num;
decNumber _2num;
decSingleToNumber (_1, &_1num);
decSingleToNumber (_2, &_2num);
decNumberCompare (&_0num, &_1num, &_2num, ctx);
return decSingleFromNumber (_0, &_0num, ctx);
}
int
PREFIXED_FUNCTION_NAME (DEC_TYPE x, DEC_TYPE y)
{
decNumber dn_x, dn_y, result;
decContext context;
decContextDefault(&context, DEFAULT_CONTEXT);
FUNC_CONVERT_TO_DN(&x, &dn_x);
FUNC_CONVERT_TO_DN(&y, &dn_y);
if(decNumberIsNaN(&dn_x) || decNumberIsNaN(&dn_y))
return -1;
decNumberCompare(&result, &dn_x, &dn_y, &context);
return !decNumberIsNegative(&result) && !decNumberIsZero(&result);
}
int
INTERNAL_FUNCTION_NAME (DEC_TYPE x, DEC_TYPE y)
{
decNumber dn_x;
decNumber dn_y;
decNumber dn_result;
decContext context;
FUNC_CONVERT_TO_DN(&x, &dn_x);
FUNC_CONVERT_TO_DN(&y, &dn_y);
if(decNumberIsNaN(&dn_x) || decNumberIsNaN(&dn_y))
return 0;
decNumberCompare (&dn_result, &dn_x, &dn_y, &context);
return (-decNumberIsNegative (&dn_result)) ||
(!decNumberIsNegative (&dn_result) && !decNumberIsZero (&dn_result));
}
