DEC_TYPE PREFIXED_FUNCTION_NAME (DEC_TYPE x, DEC_TYPE y) { DEC_TYPE result; decNumber dn_x, dn_y, dn_result; decContext context; decContextDefault(&context, DEFAULT_CONTEXT); FUNC_CONVERT_TO_DN(&x, &dn_x); FUNC_CONVERT_TO_DN(&y, &dn_y); decNumberSubtract(&dn_result, &dn_x, &dn_y, &context); if (context.status != 0) { int ieee_flags = 0; if (context.status & DEC_IEEE_854_Division_by_zero) ieee_flags |= FE_DIVBYZERO; if (context.status & DEC_IEEE_854_Inexact) ieee_flags |= FE_INEXACT; if (context.status & DEC_IEEE_854_Invalid_operation) ieee_flags |= FE_INVALID; if (context.status & DEC_IEEE_854_Overflow) ieee_flags |= FE_OVERFLOW; if (context.status & DEC_IEEE_854_Underflow) ieee_flags |= FE_UNDERFLOW; if (ieee_flags != 0) feraiseexcept (ieee_flags); } FUNC_CONVERT_FROM_DN (&dn_result, &result, &context); return result; }
int main(int argc, char *argv[]) { int i; const int N = 30; // At 15 the second last term is the same as the last decNumber di, dn; char s[10000]; decContext ctx; decContextDefault(&ctx, DEC_INIT_BASE); ctx.traps = 0; ctx.digits = DECNUMDIGITS; ctx.emax=DEC_MAX_MATH; ctx.emin=-DEC_MAX_MATH; ctx.round = DEC_ROUND_HALF_EVEN; zetadk(&dn, N, N, &ctx); decNumberToString(&dn, s); printf("\t{ DFLT, \"zeta_dn\",\t\t\"%s\"\t},\n", s); for (i=0; i<N; i++) { zetadk(&di, N, i, &ctx); decNumberSubtract(&di, &dn, &di, &ctx); decNumberToString(&di, s); printf("\t{ DFLT, \"zetaC%02d\",\t\t\"%s\"\t},\n", i, s); } return 0; }
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; }
static DEC_TYPE IEEE_FUNCTION_NAME (DEC_TYPE x) { decContext context; decNumber dn_result; DEC_TYPE result; decNumber dn_x; decNumber dn_one; decNumber dn_exponent; DEC_TYPE one = DFP_CONSTANT(1.0); FUNC_CONVERT_TO_DN(&x, &dn_x); FUNC_CONVERT_TO_DN(&one, &dn_one); if (decNumberIsNaN (&dn_x)) return x+x; if (decNumberIsInfinite (&dn_x)) return decNumberIsNegative (&dn_x) ? DFP_CONSTANT(-1.0) : x; decContextDefault(&context, DEFAULT_CONTEXT); decNumberExp(&dn_exponent, &dn_x, &context); decNumberSubtract(&dn_result, &dn_exponent, &dn_one, &context); FUNC_CONVERT_FROM_DN(&dn_result, &result, &context); if (context.status & DEC_Overflow) DFP_EXCEPT (FE_OVERFLOW); return result; }
void* decSingleSubtract (decSingle* _0, const decSingle* _1, const decSingle* _2, decContext* ctx) noexcept { decNumber _0num; decNumber _1num; decNumber _2num; decSingleToNumber (_1, &_1num); decSingleToNumber (_2, &_2num); decNumberSubtract (&_0num, &_1num, &_2num, ctx); return decSingleFromNumber (_0, &_0num, ctx); }
const DecimalDecNumber &DecimalDecNumber::operator --() { if (decNumberIsNaN(&m_value)) { throw("Performing arithmetic on uninitialised decimal [Nan]"); } decNumberSubtract(&m_value, &m_value, &ONE.m_value, &m_context); return *this; }
DecimalDecNumber DecimalDecNumber::distance(const DecimalDecNumber &rhs) const { decContext contextComparison; decContextDefault(&contextComparison, DEC_INIT_BASE); // initialize contextComparison.traps=0; // no traps, thank you contextComparison.digits=DECNUMCOMPARISONDIGITS; // set precision DecimalDecNumber distance; decNumberSubtract(&distance.m_value, &m_value, &rhs.m_value, &m_context); return abs(distance); }
const DecimalDecNumber &DecimalDecNumber::operator -=(const DecimalDecNumber &rhs) { if (decNumberIsNaN(&m_value) || decNumberIsNaN(&rhs.m_value)) { // FTHROW(InvalidStateException, "Performing arithmetic on uninitialised decimal [Nan]"); throw("Performing arithmetic on uninitialised decimal [Nan]"); } decNumberSubtract(&m_value, &m_value, &rhs.m_value, &m_context); return *this; }
static DEC_TYPE IEEE_FUNCTION_NAME (DEC_TYPE x) { decContext context; decNumber dn_result; DEC_TYPE result, one, temp; decNumber dn_x, dn_temp, dn_one; /* int comp;*/ one=DFP_CONSTANT(1.0); FUNC_CONVERT_TO_DN (&one, &dn_one); FUNC_CONVERT_TO_DN (&x, &dn_x); /* Handle NaN and early exit for x==0 */ if (decNumberIsNaN (&dn_x) || decNumberIsZero (&dn_x)) return x + x; decContextDefault (&context, DEFAULT_CONTEXT); decNumberAbs (&dn_temp, &dn_x, &context); FUNC_CONVERT_FROM_DN (&dn_temp, &temp, &context); if(temp==one) { /* |x| == 1 -> Pole Error */ DFP_EXCEPT (FE_DIVBYZERO); return decNumberIsNegative(&dn_x) ? -DFP_HUGE_VAL:DFP_HUGE_VAL; } else if (temp>one) { /* |x| > 1 -> Domain Error (this handles +-Inf too) */ DFP_EXCEPT (FE_INVALID); return DFP_NAN; } // comp = decCompare (&dn_temp, &dn_one); // switch (comp) // { // case 0: /* |x| == 1 -> Pole Error */ // DFP_EXCEPT (FE_DIVBYZERO); // return decNumberIsNegative(&dn_x) ? -DFP_HUGE_VAL:DFP_HUGE_VAL; // case 1: /* |x| > 1 -> Domain Error (this handles +-Inf too) */ // DFP_EXCEPT (FE_INVALID); // return DFP_NAN; // } /* Using trig identity: atanh(x) = 1/2 * log((1+x)/(1-x)) */ decNumberAdd (&dn_result, &dn_one, &dn_x, &context); decNumberSubtract (&dn_temp, &dn_one, &dn_x, &context); decNumberDivide (&dn_result, &dn_result, &dn_temp, &context); decNumberLn (&dn_result, &dn_result, &context); decNumberAdd (&dn_temp, &dn_one, &dn_one, &context); /* 2 */ decNumberDivide (&dn_result, &dn_result, &dn_temp, &context); FUNC_CONVERT_FROM_DN (&dn_result, &result, &context); return result; }
static DEC_TYPE IEEE_FUNCTION_NAME (DEC_TYPE x, DEC_TYPE y) { decContext context; decNumber dn_result; DEC_TYPE result; decNumber dn_x; decNumber dn_y; decNumber dn_diff; DEC_TYPE temp_diff; DEC_TYPE temp_result; FUNC_CONVERT_TO_DN (&x, &dn_x); FUNC_CONVERT_TO_DN (&y, &dn_y); if(decNumberIsNaN (&dn_x) || decNumberIsNaN (&dn_y)) return x; decContextDefault (&context, DEFAULT_CONTEXT); decNumberSubtract (&dn_diff, &dn_x, &dn_y, &context); decNumberSubtract (&dn_result, &dn_x, &dn_x, &context); FUNC_CONVERT_FROM_DN (&dn_diff, &temp_diff, &context); FUNC_CONVERT_FROM_DN (&dn_result, &temp_result, &context); if(temp_diff>temp_result) decNumberAdd (&dn_result,&dn_result,&dn_diff,&context); /* if(decCompare (&dn_diff,&dn_result) == 1) decNumberAdd (&dn_result,&dn_result,&dn_diff,&context); */ FUNC_CONVERT_FROM_DN (&dn_result, &result, &context); if (context.status & DEC_Overflow) DFP_EXCEPT (FE_OVERFLOW); return result; }
/* Compute a factorial. * Currently, only for positive integer arguments. Needs to be extended * to a full gamma function. */ decNumber *decNumberFactorial(decNumber *r, const decNumber *x, decContext *ctx) { decNumber y, const_1; int_to_dn(&const_1, 1, ctx); decNumberCopy(&y, x); if (!decNumberIsNegative(x) || decNumberIsZero(x)) { decNumberCopy(r, &const_1); for (;;) { if (decNumberIsZero(&y)) break; if (decNumberIsInfinite(r)) break; decNumberMultiply(r, r, &y, ctx); decNumberSubtract(&y, &y, &const_1, ctx); } } return r; }
static DEC_TYPE IEEE_FUNCTION_NAME (DEC_TYPE x, DEC_TYPE y) { decContext context; decNumber dn_result; DEC_TYPE result; DEC_TYPE absx; decNumber dn_x; decNumber dn_absx; decNumber dn_y; decNumber dn_one; decNumber dn_two; decNumber dn_temp; decNumber dn_temp2; decNumber dn_temp3; int y_is_int; int y_is_oddint=0; int abs_x_vs_1; DEC_TYPE one = DFP_CONSTANT(1.0); DEC_TYPE two = DFP_CONSTANT(2.0); FUNC_CONVERT_TO_DN (&x, &dn_x); FUNC_CONVERT_TO_DN (&y, &dn_y); FUNC_CONVERT_TO_DN (&one, &dn_one); decContextDefault (&context, DEFAULT_CONTEXT); if (decNumberIsZero (&dn_y)) return one; if (decNumberIsNaN (&dn_x)) return x+x; decNumberAbs (&dn_absx, &dn_x, &context); FUNC_CONVERT_FROM_DN (&dn_absx, &absx, &context); if(absx<one) abs_x_vs_1 = -1; else if (absx==one) abs_x_vs_1 = 0; else abs_x_vs_1 = 1; /* abs_x_vs_1 = decCompare(&dn_absx, &dn_one); */ if(abs_x_vs_1 == 0 && !decNumberIsNegative (&dn_x)) /* If x == +1 */ return one; if (decNumberIsNaN (&dn_y)) return y+y; /* Detect if y is odd/an integer */ decNumberToIntegralValue (&dn_temp, &dn_y, &context); decNumberSubtract (&dn_temp2, &dn_temp, &dn_y, &context); y_is_int = decNumberIsZero (&dn_temp2); if (y_is_int) { FUNC_CONVERT_TO_DN (&two, &dn_two); decNumberDivide (&dn_temp, &dn_y, &dn_two, &context); decNumberToIntegralValue (&dn_temp2, &dn_temp, &context); decNumberSubtract (&dn_temp3, &dn_temp2, &dn_temp, &context); y_is_oddint = !decNumberIsZero (&dn_temp3); } /* Handle all special cases for which x = +-0 */ if (decNumberIsZero (&dn_x)) { if(decNumberIsNegative (&dn_y)) { if (decNumberIsInfinite (&dn_y)) /* +-0^-Inf = +Inf */ return -y; /* Pole Error for x = +-0, y < 0 */ DFP_EXCEPT (FE_DIVBYZERO); return decNumberIsNegative(&dn_x) && y_is_oddint ? -DFP_HUGE_VAL : DFP_HUGE_VAL; } return decNumberIsNegative(&dn_x) && y_is_oddint ? -DFP_CONSTANT(0.0) : DFP_CONSTANT(0.0); } /* Handle remaining special cases for x = +-Inf or y = +-Inf */ if (decNumberIsInfinite (&dn_x) || decNumberIsInfinite (&dn_y)) { if (abs_x_vs_1 == 0) /* If (-1)^(+-Inf) */ return one; if (abs_x_vs_1 < 0) /* x^(+-Inf), where 0<x<1 */ return decNumberIsNegative (&dn_y) ? DFP_HUGE_VAL : DFP_CONSTANT(0.0); if (decNumberIsNegative (&dn_y)) result = DFP_CONSTANT(0.0); else result = (DEC_TYPE)DEC_INFINITY; if (y_is_oddint && decNumberIsNegative(&dn_x)) result = -result; return result; } /* Domain Error: x < 0 && y is a finite non-int */ if (decNumberIsNegative (&dn_x) && !y_is_int) { DFP_EXCEPT (FE_INVALID); return DFP_NAN; } decNumberPower (&dn_result, &dn_x, &dn_y, &context); FUNC_CONVERT_FROM_DN (&dn_result, &result, &context); if (context.status & DEC_Overflow) DFP_EXCEPT (FE_OVERFLOW); if (context.status & DEC_Underflow) DFP_EXCEPT (FE_UNDERFLOW); return result; }