Lines Matching defs:status
105 uint32_t *status);
113 const mpd_context_t *ctx, uint32_t *status);
115 const mpd_context_t *ctx, uint32_t *status);
117 const mpd_t *b, uint32_t *status);
120 const mpd_context_t *ctx, uint32_t *status);
487 * 'result' is NaN, status is updated with MPD_Malloc_error. Return 0.
499 mpd_qresize(mpd_t *result, mpd_ssize_t nwords, uint32_t *status)
511 return mpd_switch_to_dyn(result, nwords, status);
516 return mpd_realloc_dyn(result, nwords, status);
544 mpd_qresize_zero(mpd_t *result, mpd_ssize_t nwords, uint32_t *status)
554 return mpd_switch_to_dyn_zero(result, nwords, status);
557 else if (!mpd_realloc_dyn(result, nwords, status)) {
591 uint32_t status = 0;
592 if (!mpd_qresize(result, nwords, &status)) {
593 mpd_addstatus_raise(ctx, status);
602 uint32_t status = 0;
603 if (!mpd_qresize_zero(result, nwords, &status)) {
604 mpd_addstatus_raise(ctx, status);
757 workctx->status = 0;
787 mpd_qmaxcoeff(mpd_t *result, const mpd_context_t *ctx, uint32_t *status)
794 if (!mpd_qresize(result, len, status)) {
1085 /* Set result of NaN with an error status */
1087 mpd_seterror(mpd_t *result, uint32_t flags, uint32_t *status)
1093 *status |= flags;
1099 uint32_t *status)
1118 mpd_qfinalize(result, ctx, status);
1124 uint32_t *status)
1127 mpd_qfinalize(result, ctx, status);
1133 uint32_t *status)
1135 mpd_qsset_ssize(result, a, ctx, status);
1141 uint32_t *status)
1143 mpd_qsset_uint(result, a, ctx, status);
1150 uint32_t *status)
1152 mpd_qsset_ssize(result, a, ctx, status);
1158 uint32_t *status)
1160 mpd_qsset_uint(result, a, ctx, status);
1167 uint32_t *status)
1170 mpd_qsset_ssize(result, a, ctx, status);
1176 uint32_t *status)
1179 mpd_qfinalize(result, ctx, status);
1185 uint32_t *status)
1187 mpd_qset_ssize(result, a, ctx, status);
1193 uint32_t *status)
1195 mpd_qset_uint(result, a, ctx, status);
1201 _c32setu64(mpd_t *result, uint64_t u, uint8_t sign, uint32_t *status)
1214 if (!mpd_qresize(result, len, status)) {
1229 uint32_t *status)
1231 _c32setu64(result, a, MPD_POS, status);
1232 mpd_qfinalize(result, ctx, status);
1238 uint32_t *status)
1255 _c32setu64(result, u, sign, status);
1256 mpd_qfinalize(result, ctx, status);
1264 uint32_t *status)
1267 mpd_qset_ssize(result, a, ctx, status);
1269 _c32_qset_i64(result, a, ctx, status);
1275 mpd_qset_i64_exact(mpd_t *result, int64_t a, uint32_t *status)
1281 mpd_qset_ssize(result, a, &maxcontext, status);
1283 _c32_qset_i64(result, a, &maxcontext, status);
1286 if (*status & (MPD_Inexact|MPD_Rounded|MPD_Clamped)) {
1288 mpd_seterror(result, MPD_Invalid_operation, status);
1290 *status &= MPD_Errors;
1296 uint32_t *status)
1299 mpd_qset_uint(result, a, ctx, status);
1301 _c32_qset_u64(result, a, ctx, status);
1307 mpd_qset_u64_exact(mpd_t *result, uint64_t a, uint32_t *status)
1313 mpd_qset_uint(result, a, &maxcontext, status);
1315 _c32_qset_u64(result, a, &maxcontext, status);
1318 if (*status & (MPD_Inexact|MPD_Rounded|MPD_Clamped)) {
1320 mpd_seterror(result, MPD_Invalid_operation, status);
1322 *status &= MPD_Errors;
1334 _mpd_qget_uint(int use_sign, const mpd_t *a, uint32_t *status)
1341 *status |= MPD_Invalid_operation;
1348 *status |= MPD_Invalid_operation;
1353 *status |= MPD_Invalid_operation;
1359 *status |= MPD_Invalid_operation;
1374 *status |= MPD_Invalid_operation;
1381 *status |= MPD_Invalid_operation;
1397 mpd_qget_uint(const mpd_t *a, uint32_t *status)
1399 return _mpd_qget_uint(1, a, status);
1404 mpd_qabs_uint(const mpd_t *a, uint32_t *status)
1406 return _mpd_qget_uint(0, a, status);
1411 mpd_qget_ssize(const mpd_t *a, uint32_t *status)
1419 *status |= workstatus;
1431 *status |= MPD_Invalid_operation;
1441 _c32_qget_u64(int use_sign, const mpd_t *a, uint32_t *status)
1452 *status |= MPD_Invalid_operation;
1459 *status |= MPD_Invalid_operation;
1463 *status |= MPD_Invalid_operation;
1468 *status |= MPD_Invalid_operation;
1473 mpd_qrescale(&tmp, a, 0, &maxcontext, &maxcontext.status);
1474 maxcontext.status &= ~MPD_Rounded;
1475 if (maxcontext.status != 0) {
1476 *status |= (maxcontext.status|MPD_Invalid_operation); /* GCOV_NOT_REACHED */
1497 _c32_qget_i64(const mpd_t *a, uint32_t *status)
1502 u = _c32_qget_u64(0, a, status);
1503 if (*status&MPD_Invalid_operation) {
1515 *status |= MPD_Invalid_operation;
1523 mpd_qget_u64(const mpd_t *a, uint32_t *status)
1525 return mpd_qget_uint(a, status);
1530 mpd_qget_i64(const mpd_t *a, uint32_t *status)
1532 return mpd_qget_ssize(a, status);
1537 mpd_qget_u32(const mpd_t *a, uint32_t *status)
1543 *status |= workstatus;
1547 *status |= MPD_Invalid_operation;
1556 mpd_qget_i32(const mpd_t *a, uint32_t *status)
1562 *status |= workstatus;
1566 *status |= MPD_Invalid_operation;
1576 mpd_qget_u64(const mpd_t *a, uint32_t *status)
1580 *status |= workstatus;
1586 mpd_qget_i64(const mpd_t *a, uint32_t *status)
1590 *status |= workstatus;
1597 mpd_qget_u32(const mpd_t *a, uint32_t *status)
1599 return mpd_qget_uint(a, status);
1604 mpd_qget_i32(const mpd_t *a, uint32_t *status)
1606 return mpd_qget_ssize(a, status);
1622 uint32_t *status)
1625 *status |= mpd_issnan(a) ? MPD_Invalid_operation : 0;
1626 mpd_qcopy(result, a, status);
1641 const mpd_context_t *ctx, uint32_t *status)
1647 *status |= MPD_Invalid_operation;
1650 *status |= MPD_Invalid_operation;
1655 mpd_qcopy(result, choice, status);
1670 const mpd_context_t *ctx, uint32_t *status)
1676 *status |= MPD_Invalid_operation;
1680 *status |= MPD_Invalid_operation;
1683 *status |= MPD_Invalid_operation;
1691 mpd_qcopy(result, choice, status);
1737 uint32_t *status)
1753 _mpd_check_exp(dec, ctx, status);
1761 _mpd_check_exp(dec, ctx, status);
1771 uint32_t *status)
1776 if (!mpd_qresize(dec, dec->len+1, status)) {
1793 uint32_t *status)
1798 if (!mpd_qresize(dec, dec->len+1, status)) {
1806 mpd_seterror(dec, MPD_Invalid_operation, status);
1817 _mpd_check_exp(mpd_t *dec, const mpd_context_t *ctx, uint32_t *status)
1831 *status |= MPD_Clamped;
1842 mpd_qmaxcoeff(dec, ctx, status);
1847 mpd_qmaxcoeff(dec, ctx, status);
1856 mpd_qmaxcoeff(dec, ctx, status);
1867 *status |= MPD_Overflow|MPD_Inexact|MPD_Rounded;
1875 if (!mpd_qshiftl(dec, dec, shift, status)) {
1879 *status |= MPD_Clamped;
1883 *status |= MPD_Subnormal;
1894 *status |= MPD_Clamped;
1899 *status |= MPD_Subnormal;
1908 _mpd_apply_round_excess(dec, rnd, ctx, status);
1909 *status |= MPD_Rounded;
1911 *status |= (MPD_Inexact|MPD_Underflow);
1914 *status |= MPD_Clamped;
1930 mpd_check_underflow(mpd_t *dec, const mpd_context_t *ctx, uint32_t *status)
1934 *status |= MPD_Underflow;
1940 _mpd_check_round(mpd_t *dec, const mpd_context_t *ctx, uint32_t *status)
1954 _mpd_apply_round(dec, rnd, ctx, status);
1955 *status |= MPD_Rounded;
1957 *status |= MPD_Inexact;
1964 mpd_qfinalize(mpd_t *result, const mpd_context_t *ctx, uint32_t *status)
1973 _mpd_check_exp(result, ctx, status);
1974 _mpd_check_round(result, ctx, status);
1997 * Copy a decimal. In case of an error, status is set to MPD_Malloc_error.
2000 mpd_qcopy(mpd_t *result, const mpd_t *a, uint32_t *status)
2004 if (!mpd_qresize(result, a->len, status)) {
2055 * status is set to MPD_Malloc_error and the return value is NULL.
2076 * status is set to MPD_Malloc_error.
2079 mpd_qcopy_abs(mpd_t *result, const mpd_t *a, uint32_t *status)
2081 if (!mpd_qcopy(result, a, status)) {
2090 * status is set to MPD_Malloc_error.
2093 mpd_qcopy_negate(mpd_t *result, const mpd_t *a, uint32_t *status)
2095 if (!mpd_qcopy(result, a, status)) {
2104 * second operand. In case of an error, the status is set to MPD_Malloc_error.
2107 mpd_qcopy_sign(mpd_t *result, const mpd_t *a, const mpd_t *b, uint32_t *status)
2111 if (!mpd_qcopy(result, a, status)) {
2325 mpd_qcmp(const mpd_t *a, const mpd_t *b, uint32_t *status)
2329 *status |= MPD_Invalid_operation;
2344 const mpd_context_t *ctx, uint32_t *status)
2349 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
2362 const mpd_context_t *ctx, uint32_t *status)
2367 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
2368 *status |= MPD_Invalid_operation;
2502 mpd_qshiftl(mpd_t *result, const mpd_t *a, mpd_ssize_t n, uint32_t *status)
2510 return mpd_qcopy(result, a, status);
2514 if (!mpd_qresize(result, size, status)) {
2629 mpd_qshiftr(mpd_t *result, const mpd_t *a, mpd_ssize_t n, uint32_t *status)
2638 if (!mpd_qcopy(result, a, status)) {
2654 mpd_qresize(result, size, status);
2657 if (!mpd_qresize(result, size, status)) {
2679 const mpd_context_t *ctx, uint32_t *status)
2689 mpd_seterror(result, MPD_Invalid_operation, status);
2696 if (!mpd_qresize(result, big->len, status)) {
2758 mpd_qresize(result, result->len, status);
2764 mpd_seterror(result, MPD_Invalid_operation, status);
2802 uint32_t *status)
2810 mpd_seterror(result, MPD_Invalid_operation, status);
2817 if (!mpd_qresize(result, len, status)) {
2838 mpd_qresize(result, result->len, status);
2844 mpd_seterror(result, MPD_Invalid_operation, status);
2850 uint32_t *status)
2853 if (mpd_qcheck_nan(result, a, ctx, status)) {
2860 *status |= MPD_Division_by_zero;
2863 mpd_qset_ssize(result, mpd_adjexp(a), ctx, status);
2870 const mpd_context_t *ctx, uint32_t *status)
2880 mpd_seterror(result, MPD_Invalid_operation, status);
2887 if (!mpd_qresize(result, big->len, status)) {
2951 mpd_qresize(result, result->len, status);
2957 mpd_seterror(result, MPD_Invalid_operation, status);
2966 const mpd_context_t *ctx, uint32_t *status)
2975 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
2980 mpd_seterror(result, MPD_Invalid_operation, status);
2986 mpd_seterror(result, MPD_Invalid_operation, status);
2990 mpd_seterror(result, MPD_Invalid_operation, status);
2994 mpd_qcopy(result, a, status);
3008 if (!mpd_qcopy(&tmp, a, status)) {
3009 mpd_seterror(result, MPD_Malloc_error, status);
3016 if (!mpd_qshiftl(&big, a, lshift, status)) {
3017 mpd_seterror(result, MPD_Malloc_error, status);
3022 if (mpd_qshiftr(&small, a, rshift, status) == MPD_UINT_MAX) {
3023 mpd_seterror(result, MPD_Malloc_error, status);
3026 _mpd_qadd(result, &big, &small, ctx, status);
3042 const mpd_context_t *ctx, uint32_t *status)
3055 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
3060 mpd_seterror(result, MPD_Invalid_operation, status);
3069 mpd_seterror(result, MPD_Invalid_operation, status);
3073 mpd_qcopy(result, a, status);
3099 mpd_qcopy(result, a, status);
3102 mpd_qfinalize(result, ctx, status);
3112 uint32_t *status)
3115 if (mpd_qcheck_nan(result, a, ctx, status)) {
3118 mpd_qcopy(result, a, status);
3123 mpd_qshiftl(result, a, n, status);
3127 if (!mpd_qcopy(result, a, status)) {
3134 mpd_seterror(result, MPD_Invalid_operation, status);
3144 uint32_t *status)
3150 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
3155 mpd_seterror(result, MPD_Invalid_operation, status);
3161 mpd_seterror(result, MPD_Invalid_operation, status);
3165 mpd_seterror(result, MPD_Invalid_operation, status);
3169 mpd_qcopy(result, a, status);
3174 mpd_qshiftl(result, a, n, status);
3178 if (!mpd_qcopy(result, a, status)) {
3189 const mpd_context_t *ctx, uint32_t *status)
3199 mpd_seterror(result, MPD_Invalid_operation, status);
3206 if (!mpd_qresize(result, big->len, status)) {
3270 mpd_qresize(result, result->len, status);
3276 mpd_seterror(result, MPD_Invalid_operation, status);
3291 uint32_t *status)
3294 if (mpd_qcheck_nan(result, a, ctx, status)) {
3300 mpd_qminus(result, a, ctx, status);
3303 mpd_qplus(result, a, ctx, status);
3318 uint32_t *status)
3322 mpd_seterror(result, MPD_Invalid_operation, status);
3336 const mpd_context_t *ctx, uint32_t *status)
3400 if (!mpd_qshiftl(&big_aligned, big, shift, status)) {
3401 mpd_seterror(result, MPD_Malloc_error, status);
3417 if (!mpd_qresize(result, newsize, status)) {
3428 if (!mpd_qresize(result, newsize, status)) {
3454 (void)mpd_qresize(result, newsize, status);
3477 const mpd_context_t *ctx, uint32_t *status)
3479 _mpd_qaddsub(result, a, b, mpd_sign(b), ctx, status);
3485 const mpd_context_t *ctx, uint32_t *status)
3487 _mpd_qaddsub(result, a, b, !mpd_sign(b), ctx, status);
3493 const mpd_context_t *ctx, uint32_t *status)
3496 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
3499 _mpd_qaddsub_inf(result, a, b, mpd_sign(b), status);
3503 _mpd_qaddsub(result, a, b, mpd_sign(b), ctx, status);
3504 mpd_qfinalize(result, ctx, status);
3510 const mpd_context_t *ctx, uint32_t *status)
3515 *status |= workstatus;
3517 mpd_seterror(result, MPD_Invalid_operation, status);
3524 const mpd_context_t *ctx, uint32_t *status)
3527 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
3530 _mpd_qaddsub_inf(result, a, b, !mpd_sign(b), status);
3534 _mpd_qaddsub(result, a, b, !mpd_sign(b), ctx, status);
3535 mpd_qfinalize(result, ctx, status);
3541 const mpd_context_t *ctx, uint32_t *status)
3546 *status |= workstatus;
3548 mpd_seterror(result, MPD_Invalid_operation, status);
3555 const mpd_context_t *ctx, uint32_t *status)
3561 mpd_qsset_ssize(&bb, b, &maxcontext, status);
3562 mpd_qadd(result, a, &bb, ctx, status);
3569 const mpd_context_t *ctx, uint32_t *status)
3575 mpd_qsset_uint(&bb, b, &maxcontext, status);
3576 mpd_qadd(result, a, &bb, ctx, status);
3583 const mpd_context_t *ctx, uint32_t *status)
3589 mpd_qsset_ssize(&bb, b, &maxcontext, status);
3590 mpd_qsub(result, a, &bb, ctx, status);
3597 const mpd_context_t *ctx, uint32_t *status)
3603 mpd_qsset_uint(&bb, b, &maxcontext, status);
3604 mpd_qsub(result, a, &bb, ctx, status);
3611 const mpd_context_t *ctx, uint32_t *status)
3613 mpd_qadd_ssize(result, a, b, ctx, status);
3619 const mpd_context_t *ctx, uint32_t *status)
3621 mpd_qadd_uint(result, a, b, ctx, status);
3628 const mpd_context_t *ctx, uint32_t *status)
3630 mpd_qadd_ssize(result, a, b, ctx, status);
3636 const mpd_context_t *ctx, uint32_t *status)
3638 mpd_qadd_uint(result, a, b, ctx, status);
3644 const mpd_context_t *ctx, uint32_t *status)
3650 mpd_qset_i64(&bb, b, &maxcontext, status);
3651 mpd_qadd(result, a, &bb, ctx, status);
3658 const mpd_context_t *ctx, uint32_t *status)
3664 mpd_qset_u64(&bb, b, &maxcontext, status);
3665 mpd_qadd(result, a, &bb, ctx, status);
3673 const mpd_context_t *ctx, uint32_t *status)
3675 mpd_qsub_ssize(result, a, b, ctx, status);
3681 const mpd_context_t *ctx, uint32_t *status)
3683 mpd_qsub_uint(result, a, b, ctx, status);
3690 const mpd_context_t *ctx, uint32_t *status)
3692 mpd_qsub_ssize(result, a, b, ctx, status);
3698 const mpd_context_t *ctx, uint32_t *status)
3700 mpd_qsub_uint(result, a, b, ctx, status);
3706 const mpd_context_t *ctx, uint32_t *status)
3712 mpd_qset_i64(&bb, b, &maxcontext, status);
3713 mpd_qsub(result, a, &bb, ctx, status);
3720 const mpd_context_t *ctx, uint32_t *status)
3726 mpd_qset_u64(&bb, b, &maxcontext, status);
3727 mpd_qsub(result, a, &bb, ctx, status);
3736 const mpd_context_t *ctx, uint32_t *status)
3740 mpd_seterror(result, MPD_Invalid_operation, status);
3748 *status |= MPD_Clamped;
3755 const mpd_context_t *ctx, uint32_t *status)
3768 if (mpd_qcheck_nans(q, a, b, ctx, status)) {
3771 _mpd_qdiv_inf(q, a, b, ctx, status);
3776 mpd_seterror(q, MPD_Division_undefined, status);
3780 *status |= MPD_Division_by_zero;
3787 mpd_qfinalize(q, ctx, status);
3795 if (!mpd_qshiftl(&aligned, a, shift, status)) {
3796 mpd_seterror(q, MPD_Malloc_error, status);
3803 if (!mpd_qshiftl(&aligned, b, shift, status)) {
3804 mpd_seterror(q, MPD_Malloc_error, status);
3813 if (!mpd_qresize(q, newsize, status)) {
3814 mpd_seterror(q, MPD_Malloc_error, status);
3827 mpd_seterror(q, MPD_Malloc_error, status);
3834 _mpd_base_ndivmod(q, &r, a, b, status);
3847 mpd_qresize(q, newsize, status);
3871 mpd_qfinalize(q, ctx, status);
3877 const mpd_context_t *ctx, uint32_t *status)
3884 if (!mpd_qcopy(&aa, a, status)) {
3885 mpd_seterror(q, MPD_Malloc_error, status);
3892 if (!mpd_qcopy(&bb, b, status)) {
3893 mpd_seterror(q, MPD_Malloc_error, status);
3927 *status |= (xstatus&MPD_Errors);
3933 ystatus = *status | ((ystatus|xstatus)&MPD_Errors);
3934 mpd_seterror(q, ystatus, status);
3938 *status |= xstatus;
3950 const mpd_context_t *ctx, uint32_t *status)
3961 if (!mpd_qcopy(r, a, status)) {
3974 if (!mpd_qshiftl(r, a, shift, status)) {
3980 if (!mpd_qcopy(r, a, status)) {
3988 *status |= MPD_Division_impossible;
4003 if (!mpd_qshiftl(&aligned, a, shift, status)) {
4011 if (!mpd_qshiftl(&aligned, b, shift, status)) {
4021 if (!mpd_qresize(q, qsize, status)) {
4028 if (!mpd_qresize(r, rsize, status)) {
4047 *status |= MPD_Malloc_error;
4052 _mpd_base_ndivmod(q, r, a, b, status);
4062 mpd_qresize(q, qsize, status);
4068 *status |= MPD_Division_impossible;
4074 mpd_qresize(r, rsize, status);
4093 const mpd_context_t *ctx, uint32_t *status)
4098 if (mpd_qcheck_nans(q, a, b, ctx, status)) {
4099 mpd_qcopy(r, q, status);
4110 *status |= MPD_Invalid_operation;
4114 if (!mpd_qcopy(r, a, status)) {
4115 mpd_seterror(q, MPD_Malloc_error, status);
4118 mpd_qfinalize(r, ctx, status);
4129 *status |= MPD_Division_undefined;
4134 *status |= (MPD_Division_by_zero|MPD_Invalid_operation);
4139 _mpd_qdivmod(q, r, a, b, ctx, status);
4140 mpd_qfinalize(q, ctx, status);
4141 mpd_qfinalize(r, ctx, status);
4146 const mpd_context_t *ctx, uint32_t *status)
4152 if (mpd_qcheck_nans(q, a, b, ctx, status)) {
4156 mpd_seterror(q, MPD_Invalid_operation, status);
4172 mpd_seterror(q, MPD_Division_undefined, status);
4176 *status |= MPD_Division_by_zero;
4182 _mpd_qdivmod(q, &r, a, b, ctx, status);
4184 mpd_qfinalize(q, ctx, status);
4190 const mpd_context_t *ctx, uint32_t *status)
4196 mpd_qsset_ssize(&bb, b, &maxcontext, status);
4197 mpd_qdiv(result, a, &bb, ctx, status);
4204 const mpd_context_t *ctx, uint32_t *status)
4210 mpd_qsset_uint(&bb, b, &maxcontext, status);
4211 mpd_qdiv(result, a, &bb, ctx, status);
4218 const mpd_context_t *ctx, uint32_t *status)
4220 mpd_qdiv_ssize(result, a, b, ctx, status);
4226 const mpd_context_t *ctx, uint32_t *status)
4228 mpd_qdiv_uint(result, a, b, ctx, status);
4235 const mpd_context_t *ctx, uint32_t *status)
4237 mpd_qdiv_ssize(result, a, b, ctx, status);
4243 const mpd_context_t *ctx, uint32_t *status)
4245 mpd_qdiv_uint(result, a, b, ctx, status);
4251 const mpd_context_t *ctx, uint32_t *status)
4257 mpd_qset_i64(&bb, b, &maxcontext, status);
4258 mpd_qdiv(result, a, &bb, ctx, status);
4265 const mpd_context_t *ctx, uint32_t *status)
4271 mpd_qset_u64(&bb, b, &maxcontext, status);
4272 mpd_qdiv(result, a, &bb, ctx, status);
4279 _mpd_zeropad(mpd_t *result, const mpd_context_t *ctx, uint32_t *status)
4284 mpd_qshiftl(result, result, shift, status);
4292 uint32_t *status)
4302 *status |= MPD_Rounded|MPD_Inexact;
4383 uint32_t *status)
4421 *status |= MPD_Overflow|MPD_Inexact|MPD_Rounded;
4425 *status |= (MPD_Inexact|MPD_Rounded|MPD_Subnormal|
4432 if (_mpd_qexp_check_one(result, a, ctx, status)) {
4441 if (!mpd_qcopy(result, a, status)) {
4455 mpd_seterror(result, MPD_Invalid_operation, status); /* GCOV_UNLIKELY */
4464 mpd_qdiv(&tmp, result, &word, &workctx, &workctx.status);
4465 mpd_qfma(&sum, &sum, &tmp, &one, &workctx, &workctx.status);
4469 _mpd_qpow_uint(result, &sum, mpd_pow10[t], MPD_POS, &workctx, status);
4472 _mpd_qpow_uint(result, &sum, mpd_pow10[t], MPD_POS, &workctx, status);
4477 &workctx, status);
4478 _mpd_qpow_uint(result, &tmp, mpd_pow10[t], MPD_POS, &workctx, status);
4484 *status |= (workctx.status&MPD_Errors);
4485 *status |= (MPD_Inexact|MPD_Rounded);
4491 uint32_t *status)
4496 if (mpd_qcheck_nan(result, a, ctx, status)) {
4525 if (!mpd_qcopy(&aa, a, status)) {
4526 mpd_seterror(result, MPD_Malloc_error, status);
4539 *status |= workstatus;
4562 mpd_qadd(&t1, result, &ulp, &workctx, &workctx.status);
4563 mpd_qsub(&t2, result, &ulp, &workctx, &workctx.status);
4565 mpd_qcmp(&t1, &t2, status) == 0) {
4567 _mpd_zeropad(result, &workctx, status);
4568 mpd_check_underflow(result, &workctx, status);
4569 mpd_qfinalize(result, &workctx, status);
4580 _mpd_qexp(result, a, &workctx, status);
4581 _mpd_zeropad(result, &workctx, status);
4582 mpd_check_underflow(result, &workctx, status);
4583 mpd_qfinalize(result, &workctx, status);
4590 const mpd_context_t *ctx, uint32_t *status)
4597 mpd_seterror(result, MPD_Malloc_error, status);
4609 *status |= workstatus;
4707 mpd_qln10(mpd_t *result, mpd_ssize_t prec, uint32_t *status)
4722 rnd = mpd_qshiftr(result, &_mpd_ln10, shift, status);
4724 mpd_seterror(result, MPD_Malloc_error, status);
4732 _mpd_apply_round_excess(result, rnd, &maxcontext, status);
4733 *status |= (MPD_Inexact|MPD_Rounded);
4744 _mpd_qexp(&tmp, result, &varcontext, status);
4746 mpd_qmul(&tmp, &static10, &tmp, &varcontext, status);
4747 mpd_qsub(&tmp, &tmp, &one, &maxcontext, status);
4748 mpd_qadd(result, result, &tmp, &maxcontext, status);
4756 mpd_qfinalize(result, &maxcontext, status);
4843 uint32_t *status)
4862 if (!mpd_qcopy(&v, a, status)) {
4863 mpd_seterror(result, MPD_Malloc_error, status);
4919 _mpd_qsub(&tmp, &v, &one, &maxcontext, &maxcontext.status);
4920 if (maxcontext.status & MPD_Errors) {
4921 mpd_seterror(result, MPD_Malloc_error, status);
4952 _mpd_qexp(&tmp, z, &varcontext, status);
4957 mpd_qshiftr(&vtmp, &v, shift, status);
4959 mpd_qmul(&tmp, &vtmp, &tmp, &varcontext, status);
4962 mpd_qmul(&tmp, &v, &tmp, &varcontext, status);
4965 mpd_qsub(&tmp, &tmp, &one, &maxcontext, status);
4966 mpd_qadd(z, z, &tmp, &maxcontext, status);
4996 mpd_qln10(&v, maxprec+1, status);
4997 mpd_qmul_ssize(&tmp, &v, t, &maxcontext, status);
4998 mpd_qadd(result, &tmp, z, &maxcontext, status);
5002 *status |= (MPD_Inexact|MPD_Rounded);
5011 uint32_t *status)
5017 if (mpd_qcheck_nan(result, a, ctx, status)) {
5021 mpd_seterror(result, MPD_Invalid_operation, status);
5032 mpd_seterror(result, MPD_Invalid_operation, status);
5064 *status |= MPD_Overflow|MPD_Inexact|MPD_Rounded;
5080 if (!mpd_qcopy(&aa, a, status)) {
5081 mpd_seterror(result, MPD_Malloc_error, status);
5091 _mpd_qln(result, a, &workctx, status);
5096 mpd_qadd(&t1, result, &ulp, &workctx, &workctx.status);
5097 mpd_qsub(&t2, result, &ulp, &workctx, &workctx.status);
5099 mpd_qcmp(&t1, &t2, status) == 0) {
5101 mpd_check_underflow(result, &workctx, status);
5102 mpd_qfinalize(result, &workctx, status);
5113 _mpd_qln(result, a, &workctx, status);
5114 mpd_check_underflow(result, &workctx, status);
5115 mpd_qfinalize(result, &workctx, status);
5129 const mpd_context_t *ctx, uint32_t *status)
5138 _mpd_qln(result, a, &workctx, status);
5140 mpd_qln10(&ln10, workctx.prec, status);
5147 _mpd_qdiv(NO_IDEAL_EXP, result, result, &ln10, &workctx, status);
5155 uint32_t *status)
5164 if (mpd_qcheck_nan(result, a, ctx, status)) {
5168 mpd_seterror(result, MPD_Invalid_operation, status);
5179 mpd_seterror(result, MPD_Invalid_operation, status);
5190 mpd_qfinalize(result, &workctx, status);
5216 *status |= MPD_Overflow|MPD_Inexact|MPD_Rounded;
5229 if (!mpd_qcopy(&aa, a, status)) {
5230 mpd_seterror(result, MPD_Malloc_error, status);
5240 _mpd_qlog10(SKIP_FINALIZE, result, a, &workctx, status);
5245 mpd_qadd(&t1, result, &ulp, &workctx, &workctx.status);
5246 mpd_qsub(&t2, result, &ulp, &workctx, &workctx.status);
5248 mpd_qcmp(&t1, &t2, status) == 0) {
5250 mpd_check_underflow(result, &workctx, status);
5251 mpd_qfinalize(result, &workctx, status);
5262 _mpd_qlog10(DO_FINALIZE, result, a, &workctx, status);
5263 mpd_check_underflow(result, &workctx, status);
5274 const mpd_context_t *ctx, uint32_t *status)
5279 mpd_qcopy(result, b, status);
5282 mpd_qcopy(result, a, status);
5284 else if (mpd_qcheck_nans(result, a, b, ctx, status)) {
5294 mpd_qcopy(result, b, status);
5297 mpd_qcopy(result, a, status);
5301 mpd_qfinalize(result, ctx, status);
5310 const mpd_context_t *ctx, uint32_t *status)
5315 mpd_qcopy(result, b, status);
5318 mpd_qcopy(result, a, status);
5320 else if (mpd_qcheck_nans(result, a, b, ctx, status)) {
5330 mpd_qcopy(result, b, status);
5333 mpd_qcopy(result, a, status);
5337 mpd_qfinalize(result, ctx, status);
5347 const mpd_context_t *ctx, uint32_t *status)
5352 mpd_qcopy(result, b, status);
5355 mpd_qcopy(result, a, status);
5357 else if (mpd_qcheck_nans(result, a, b, ctx, status)) {
5367 mpd_qcopy(result, a, status);
5370 mpd_qcopy(result, b, status);
5374 mpd_qfinalize(result, ctx, status);
5383 const mpd_context_t *ctx, uint32_t *status)
5388 mpd_qcopy(result, b, status);
5391 mpd_qcopy(result, a, status);
5393 else if (mpd_qcheck_nans(result, a, b, ctx, status)) {
5403 mpd_qcopy(result, a, status);
5406 mpd_qcopy(result, b, status);
5410 mpd_qfinalize(result, ctx, status);
5872 _mpd_qmul_inf(mpd_t *result, const mpd_t *a, const mpd_t *b, uint32_t *status)
5876 mpd_seterror(result, MPD_Invalid_operation, status);
5885 mpd_seterror(result, MPD_Invalid_operation, status);
5898 const mpd_context_t *ctx, uint32_t *status)
5907 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
5910 _mpd_qmul_inf(result, a, b, status);
5937 if (!mpd_qresize(result, rsize, status)) {
5969 mpd_seterror(result, MPD_Malloc_error, status);
5986 mpd_qresize(result, result->len, status);
5993 const mpd_context_t *ctx, uint32_t *status)
5995 _mpd_qmul(result, a, b, ctx, status);
5996 mpd_qfinalize(result, ctx, status);
6002 const mpd_context_t *ctx, uint32_t *status)
6007 *status |= workstatus;
6009 mpd_seterror(result, MPD_Invalid_operation, status);
6016 const mpd_context_t *ctx, uint32_t *status)
6022 mpd_qsset_ssize(&bb, b, &maxcontext, status);
6023 mpd_qmul(result, a, &bb, ctx, status);
6030 const mpd_context_t *ctx, uint32_t *status)
6036 mpd_qsset_uint(&bb, b, &maxcontext, status);
6037 mpd_qmul(result, a, &bb, ctx, status);
6043 const mpd_context_t *ctx, uint32_t *status)
6045 mpd_qmul_ssize(result, a, b, ctx, status);
6050 const mpd_context_t *ctx, uint32_t *status)
6052 mpd_qmul_uint(result, a, b, ctx, status);
6058 const mpd_context_t *ctx, uint32_t *status)
6060 mpd_qmul_ssize(result, a, b, ctx, status);
6065 const mpd_context_t *ctx, uint32_t *status)
6067 mpd_qmul_uint(result, a, b, ctx, status);
6073 const mpd_context_t *ctx, uint32_t *status)
6079 mpd_qset_i64(&bb, b, &maxcontext, status);
6080 mpd_qmul(result, a, &bb, ctx, status);
6087 const mpd_context_t *ctx, uint32_t *status)
6093 mpd_qset_u64(&bb, b, &maxcontext, status);
6094 mpd_qmul(result, a, &bb, ctx, status);
6102 uint32_t *status)
6105 if (mpd_qcheck_nan(result, a, ctx, status)) {
6111 mpd_qcopy_abs(result, a, status);
6114 mpd_qcopy_negate(result, a, status);
6117 mpd_qfinalize(result, ctx, status);
6123 uint32_t *status)
6126 if (mpd_qcheck_nan(result, a, ctx, status)) {
6132 mpd_qcopy_abs(result, a, status);
6135 mpd_qcopy(result, a, status);
6138 mpd_qfinalize(result, ctx, status);
6144 uint32_t *status)
6150 if (mpd_qcheck_nan(result, a, ctx, status)) {
6156 mpd_qcopy(result, a, status);
6161 mpd_qmaxcoeff(result, ctx, status);
6173 if (!mpd_qcopy(result, a, status)) {
6177 mpd_qfinalize(result, &workctx, &workctx.status);
6178 if (workctx.status&(MPD_Inexact|MPD_Errors)) {
6179 *status |= (workctx.status&MPD_Errors);
6183 workctx.status = 0;
6184 mpd_qsub(result, a, &tiny, &workctx, &workctx.status);
6185 *status |= (workctx.status&MPD_Errors);
6191 uint32_t *status)
6197 if (mpd_qcheck_nan(result, a, ctx, status)) {
6203 mpd_qcopy(result, a, status);
6207 mpd_qmaxcoeff(result, ctx, status);
6220 if (!mpd_qcopy(result, a, status)) {
6224 mpd_qfinalize(result, &workctx, &workctx.status);
6225 if (workctx.status & (MPD_Inexact|MPD_Errors)) {
6226 *status |= (workctx.status&MPD_Errors);
6230 workctx.status = 0;
6231 mpd_qadd(result, a, &tiny, &workctx, &workctx.status);
6232 *status |= (workctx.status&MPD_Errors);
6241 const mpd_context_t *ctx, uint32_t *status)
6245 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
6251 mpd_qcopy_sign(result, a, b, status);
6256 mpd_qnext_plus(result, a, ctx, status);
6259 mpd_qnext_minus(result, a, ctx, status);
6263 *status |= (MPD_Overflow|MPD_Rounded|MPD_Inexact);
6266 *status |= (MPD_Underflow|MPD_Subnormal|MPD_Rounded|MPD_Inexact);
6268 *status |= MPD_Clamped;
6285 uint8_t resultsign, const mpd_context_t *ctx, uint32_t *status)
6295 if (!mpd_qcopy(result, base, status)) {
6311 *status |= workstatus;
6327 const mpd_context_t *ctx, uint32_t *status)
6337 mpd_qcopy(result, &one, status);
6342 *status |= workstatus;
6351 mpd_seterror(result, workstatus&MPD_Errors, status);
6366 const mpd_context_t *ctx, uint32_t *status)
6382 *status |= workstatus;
6389 if (!mpd_qcopy(&tbase, base, status)) {
6395 n = mpd_qabs_uint(exp, &workctx.status);
6396 if (workctx.status&MPD_Invalid_operation) {
6397 if (!mpd_qcopy(&texp, exp, status)) {
6401 _mpd_qpow_mpd(result, &tbase, &texp, resultsign, &workctx, status);
6404 _mpd_qpow_uint(result, &tbase, n, resultsign, &workctx, status);
6415 mpd_qfinalize(result, ctx, status);
6425 const mpd_context_t *ctx, uint32_t *status)
6432 mpd_qshiftl(result, &one, shift, status);
6435 *status |= (MPD_Inexact|MPD_Rounded);
6451 const mpd_context_t *ctx, uint32_t *status)
6466 *status |= (workstatus&MPD_Errors);
6474 *status |= MPD_Rounded;
6479 *status |= (MPD_Inexact|MPD_Rounded);
6484 if (!mpd_qshiftl(result, &one, shift, status)) {
6559 _lower_bound_zeta(const mpd_t *x, uint32_t *status)
6576 mpd_qsub(&scratch, x, &one, &maxctx, status);
6599 const mpd_context_t *ctx, uint32_t *status)
6608 lb_zeta = _lower_bound_zeta(&abs_x, status);
6610 mpd_seterror(result, MPD_Malloc_error, status);
6620 mpd_qfinalize(result, ctx, status);
6629 mpd_qfinalize(result, ctx, status);
6645 const mpd_context_t *ctx, uint32_t *status)
6657 const mpd_context_t *ctx, uint32_t *status)
6662 if (!mpd_qcopy(&texp, exp, status)) {
6663 mpd_seterror(result, MPD_Malloc_error, status);
6697 mpd_qln(result, base, &workctx, &workctx.status);
6698 mpd_qmul(result, result, &texp, &workctx, &workctx.status);
6699 mpd_qexp(result, result, &workctx, status);
6702 *status |= (workctx.status&MPD_Errors);
6703 *status |= (MPD_Inexact|MPD_Rounded);
6709 const mpd_context_t *ctx, uint32_t *status)
6716 if (mpd_qcheck_nans(result, base, exp, ctx, status)) {
6727 mpd_seterror(result, MPD_Invalid_operation, status);
6739 mpd_seterror(result, MPD_Invalid_operation, status);
6745 cmp = _qcheck_pow_one_inf(result, base, resultsign, ctx, status);
6776 if (_qcheck_pow_one(result, base, exp, resultsign, ctx, status) == 0) {
6779 if (_qcheck_pow_bounds(result, base, exp, resultsign, ctx, status)) {
6784 _mpd_qpow_int(result, base, exp, resultsign, ctx, status);
6787 _mpd_qpow_real(result, base, exp, ctx, status);
6790 mpd_qshiftl(result, &one, shift, status);
6797 mpd_qfinalize(result, ctx, status);
6807 const mpd_t *mod, uint32_t *status)
6814 mpd_qcopy(result, &one, status);
6818 _mpd_qmul_exact(result, result, base, &maxcontext, status);
6819 mpd_qrem(result, result, mod, &maxcontext, status);
6821 _mpd_qmul_exact(base, base, base, &maxcontext, status);
6822 mpd_qrem(base, base, mod, &maxcontext, status);
6831 const mpd_context_t *ctx, uint32_t *status)
6847 if (mpd_qcheck_3nans(result, base, exp, mod, ctx, status)) {
6850 mpd_seterror(result, MPD_Invalid_operation, status);
6856 mpd_seterror(result, MPD_Invalid_operation, status);
6860 mpd_seterror(result, MPD_Invalid_operation, status);
6864 mpd_seterror(result, MPD_Invalid_operation, status);
6871 mpd_seterror(result, MPD_Invalid_operation, status);
6879 mpd_seterror(result, MPD_Invalid_operation, status);
6889 mpd_qrescale(&tmod, mod, 0, &maxcontext, &maxcontext.status);
6890 if (maxcontext.status&MPD_Errors) {
6891 mpd_seterror(result, maxcontext.status&MPD_Errors, status);
6894 maxcontext.status = 0;
6897 mpd_qround_to_int(&tbase, base, &maxcontext, status);
6902 mpd_qround_to_int(&texp, exp, &maxcontext, status);
6907 mpd_qrem(&tbase, &tbase, &tmod, &maxcontext, status);
6908 mpd_qshiftl(result, &one, tbase_exp, status);
6909 mpd_qrem(result, result, &tmod, &maxcontext, status);
6910 _mpd_qmul_exact(&tbase, &tbase, result, &maxcontext, status);
6911 mpd_qrem(&tbase, &tbase, &tmod, &maxcontext, status);
6919 _mpd_qpowmod_uint(&tmp, &tbase, 10, &tmod, status);
6929 mpd_qcopy(result, &one, status);
6932 _mpd_qmul_exact(result, result, &tbase, &maxcontext, status);
6933 mpd_qrem(result, result, &tmod, &maxcontext, status);
6935 _mpd_qmul_exact(&tbase, &tbase, &tbase, &maxcontext, status);
6936 mpd_qrem(&tbase, &tbase, &tmod, &maxcontext, status);
6937 mpd_qdivint(&texp, &texp, &two, &maxcontext, status);
6962 const mpd_context_t *ctx, uint32_t *status)
6970 if (mpd_qcheck_nans(result, a, b, ctx, status)) {
6974 mpd_qcopy(result, a, status);
6977 mpd_seterror(result, MPD_Invalid_operation, status);
6982 mpd_seterror(result, MPD_Invalid_operation, status);
6988 mpd_qfinalize(result, ctx, status);
6995 mpd_seterror(result, MPD_Invalid_operation, status);
7001 if (!mpd_qshiftl(result, a, shift, status)) {
7010 rnd = mpd_qshiftr(result, a, shift, status);
7015 if (!_mpd_apply_round_fit(result, rnd, ctx, status)) {
7026 mpd_seterror(result, MPD_Invalid_operation, status);
7030 *status |= workstatus;
7031 mpd_qfinalize(result, ctx, status);
7036 uint32_t *status)
7042 if (mpd_qcheck_nan(result, a, ctx, status)) {
7045 mpd_qcopy(result, a, status);
7049 if (!mpd_qcopy(result, a, status)) {
7052 mpd_qfinalize(result, ctx, status);
7073 uint32_t *status)
7078 if (mpd_qcheck_nans(r, a, b, ctx, status)) {
7082 mpd_seterror(r, MPD_Invalid_operation, status);
7086 mpd_qcopy(r, a, status);
7087 mpd_qfinalize(r, ctx, status);
7095 mpd_seterror(r, MPD_Division_undefined, status);
7098 mpd_seterror(r, MPD_Invalid_operation, status);
7103 _mpd_qdivmod(&q, r, a, b, ctx, status);
7105 mpd_qfinalize(r, ctx, status);
7110 const mpd_context_t *ctx, uint32_t *status)
7121 if (mpd_qcheck_nans(r, a, b, ctx, status)) {
7125 mpd_seterror(r, MPD_Invalid_operation, status);
7129 mpd_qcopy(r, a, status);
7130 mpd_qfinalize(r, ctx, status);
7138 mpd_seterror(r, MPD_Division_undefined, status);
7141 mpd_seterror(r, MPD_Invalid_operation, status);
7147 if (!mpd_qcopy(&btmp, b, status)) {
7148 mpd_seterror(r, MPD_Malloc_error, status);
7154 _mpd_qdivmod(&q, r, a, b, ctx, status);
7172 _mpd_qsub(&q, r, b, &workctx, &workctx.status);
7176 _mpd_qadd(&q, r, b, &workctx, &workctx.status);
7179 if (workctx.status&MPD_Errors) {
7180 mpd_seterror(r, workctx.status&MPD_Errors, status);
7189 mpd_seterror(r, MPD_Division_impossible, status);
7192 mpd_qcopy(r, &q, status);
7200 mpd_qfinalize(r, ctx, status);
7205 const mpd_context_t *ctx, uint32_t *status)
7211 mpd_qcopy(result, a, status);
7224 mpd_seterror(result, MPD_Invalid_operation, status);
7227 if (!mpd_qshiftl(result, a, shift, status)) {
7234 rnd = mpd_qshiftr(result, a, shift, status);
7239 _mpd_apply_round_excess(result, rnd, ctx, status);
7240 *status |= MPD_Rounded;
7242 *status |= MPD_Inexact;
7247 *status |= MPD_Subnormal;
7261 const mpd_context_t *ctx, uint32_t *status)
7264 mpd_seterror(result, MPD_Invalid_operation, status);
7268 _mpd_qrescale(result, a, exp, ctx, status);
7281 const mpd_context_t *ctx, uint32_t *status)
7284 mpd_seterror(result, MPD_Invalid_operation, status);
7288 _mpd_qrescale(result, a, exp, ctx, status);
7295 const mpd_context_t *ctx, uint32_t *status)
7300 if (mpd_qcheck_nan(result, a, ctx, status)) {
7303 mpd_qcopy(result, a, status);
7307 mpd_qcopy(result, a, status);
7315 rnd = mpd_qshiftr(result, a, -a->exp, status);
7322 _mpd_apply_round_excess(result, rnd, ctx, status);
7324 *status |= MPD_Rounded;
7326 *status |= MPD_Inexact;
7334 uint32_t *status)
7336 (void)_mpd_qround_to_integral(TO_INT_EXACT, result, a, ctx, status);
7341 uint32_t *status)
7343 (void)_mpd_qround_to_integral(TO_INT_SILENT, result, a, ctx, status);
7348 uint32_t *status)
7351 mpd_seterror(result, MPD_Invalid_operation, status);
7355 (void)_mpd_qround_to_integral(TO_INT_TRUNC, result, a, ctx, status);
7360 uint32_t *status)
7365 mpd_seterror(result, MPD_Invalid_operation, status);
7371 &workctx, status);
7376 uint32_t *status)
7381 mpd_seterror(result, MPD_Invalid_operation, status);
7387 &workctx, status);
7430 _mpd_qreciprocal_approx(mpd_t *z, const mpd_t *v, uint32_t *status)
7442 mpd_qresize(z, 2, status);
7459 uint32_t *status)
7481 _mpd_qreciprocal_approx(z, v, status);
7498 _mpd_qmul_exact(&s, z, z, &maxcontext, status);
7502 mpd_qshiftr(&t, v, v->digits-varcontext.prec, status);
7505 mpd_qmul(&t, &t, &s, &varcontext, status);
7509 mpd_qmul(&t, v, &s, &varcontext, status);
7512 _mpd_qmul_exact(&s, z, &two, &maxcontext, status);
7516 _mpd_qsub_exact(z, &s, &t, &maxcontext, status);
7526 mpd_qfinalize(z, ctx, status);
7546 uint32_t *status)
7563 *status |= MPD_Malloc_error;
7569 *status |= MPD_Malloc_error;
7579 *status |= MPD_Division_impossible;
7588 _mpd_qreciprocal(rr, &bb, &workctx, &workctx.status);
7594 _mpd_qmul(qq, &aa, rr, &workctx, &workctx.status);
7598 mpd_qtrunc(qq, qq, &workctx, &workctx.status);
7606 _mpd_qmul(rr, &bb, qq, &workctx, &workctx.status);
7608 _mpd_qsub_exact(rr, &aa, rr, &workctx, &workctx.status);
7614 *status |= (workctx.status&MPD_Errors);
7620 *status |= MPD_Invalid_operation; /* GCOV_NOT_REACHED */
7625 _mpd_qadd_exact(rr, rr, &bb, &workctx, &workctx.status);
7626 _mpd_qadd_exact(qq, qq, &minus_one, &workctx, &workctx.status);
7634 _mpd_qsub_exact(rr, rr, &bb, &workctx, &workctx.status);
7635 _mpd_qadd_exact(qq, qq, &one, &workctx, &workctx.status);
7640 if (!mpd_qcopy(q, qq, status)) {
7646 if (!mpd_qcopy(r, rr, status)) {
7652 *status |= (workctx.status&MPD_Errors);
7753 uint32_t *status)
7777 mpd_seterror(result, MPD_Malloc_error, status);
7846 *status |= (workstatus&MPD_Errors);
7847 *status |= (MPD_Rounded|MPD_Inexact);
7852 uint32_t *status)
7857 if (mpd_qcheck_nan(result, a, ctx, status)) {
7861 mpd_seterror(result, MPD_Invalid_operation, status);
7866 *status |= MPD_Clamped;
7871 *status |= MPD_Division_by_zero;
7875 mpd_seterror(result, MPD_Invalid_operation, status);
7882 _mpd_qinvroot(result, a, &workctx, status);
7883 mpd_qfinalize(result, ctx, status);
7890 uint32_t *status)
7905 if (mpd_qcheck_nan(result, a, ctx, status)) {
7909 mpd_seterror(result, MPD_Invalid_operation, status);
7917 mpd_qfinalize(result, ctx, status);
7921 mpd_seterror(result, MPD_Invalid_operation, status);
7928 if (!mpd_qcopy(&c, a, status)) {
7934 if (!mpd_qshiftl(&c, &c, 1, status)) {
7945 if (!mpd_qshiftl(&c, &c, 2*shift, status)) {
7957 if (!mpd_qshiftl(result, &one, prec, status)) {
7962 _mpd_qdivmod(&q, &r, &c, result, &maxcontext, &maxcontext.status);
7964 mpd_seterror(result, maxcontext.status&MPD_Errors, status);
7970 _mpd_qadd_exact(result, result, &q, &maxcontext, &maxcontext.status);
7972 mpd_seterror(result, maxcontext.status&MPD_Errors, status);
7975 _mpd_qdivmod(result, &r, result, &two, &maxcontext, &maxcontext.status);
7979 _mpd_qmul_exact(&r, result, result, &maxcontext, &maxcontext.status);
7981 mpd_seterror(result, maxcontext.status&MPD_Errors, status);
7992 if (!mpd_qshiftl(result, result, -shift, status)) {
8014 mpd_qfinalize(result, &maxcontext, status);
8018 mpd_seterror(result, MPD_Malloc_error, status);
8024 uint32_t *status)
8030 if (!mpd_qcopy(&aa, a, status)) {
8031 mpd_seterror(result, MPD_Malloc_error, status);
8054 *status |= (xstatus|MPD_Errors);
8060 ystatus = *status | ((xstatus|ystatus)&MPD_Errors);
8061 mpd_seterror(result, ystatus, status);
8065 *status |= xstatus;
8178 uint32_t *status)
8191 if (!mpd_qresize(w, n+1, status)) {
8201 if (!mpd_qresize(w, n+1, status)) {
8297 uint32_t *status)
8306 if (!mpd_qresize(w, n+1, status)) {
8325 uint32_t *status)
8338 if (!mpd_qresize(w, n+1, status)) {
8348 if (!mpd_qresize(w, n+1, status)) {
8377 const mpd_t *src, uint32_t *status)
8386 *status |= MPD_Invalid_operation;
8393 *status |= MPD_Invalid_operation;
8409 if (!mpd_qshiftl(&tsrc, src, src->exp, status)) {
8414 if (mpd_qshiftr(&tsrc, src, -src->exp, status) == MPD_UINT_MAX) {
8435 *status |= MPD_Malloc_error;
8456 const mpd_t *src, uint32_t *status)
8463 *status |= MPD_Invalid_operation;
8470 *status |= MPD_Invalid_operation;
8486 if (!mpd_qshiftl(&tsrc, src, src->exp, status)) {
8491 if (mpd_qshiftr(&tsrc, src, -src->exp, status) == MPD_UINT_MAX) {
8528 *status |= MPD_Malloc_error;
8541 const mpd_context_t *ctx, uint32_t *status)
8552 mpd_seterror(result, MPD_Invalid_operation, status);
8558 mpd_seterror(result, MPD_Malloc_error, status);
8565 if (!mpd_qresize(result, rlen, status)) {
8569 n = _coeff_from_u16(result, rlen, usrc, srclen, srcbase, status);
8579 mpd_qresize(result, result->len, status);
8580 mpd_qfinalize(result, ctx, status);
8595 const mpd_context_t *ctx, uint32_t *status)
8604 mpd_seterror(result, MPD_Invalid_operation, status);
8608 if (!mpd_qresize(result, rlen, status)) {
8615 status);
8618 if (!mpd_qresize(result, srclen, status)) {
8627 status);
8632 mpd_seterror(result, MPD_Malloc_error, status);
8641 status);
8655 mpd_qresize(result, result->len, status);
8656 mpd_qfinalize(result, ctx, status);
8745 uint32_t status = 0;
8754 if (!mpd_qresize(result, len, &status)) {
8770 mpd_from_uint128_triple(mpd_t *result, const mpd_uint128_triple_t *triple, uint32_t *status)
8778 .status=0,
8859 mpd_seterror(result, MPD_Conversion_syntax, status);
8863 mpd_seterror(result, MPD_Malloc_error, status);
8962 uint32_t status = 0;
8985 if (mpd_qcmp(&coeff, &uint128_max, &status) > 0) {