51 static void bc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
120 static void bc_num_setToZero(BcNum *restrict n, size_t scale) {  in bc_num_setToZero()  argument
122 	n->scale = scale;  in bc_num_setToZero()
462 	places_rdx = nrdx ? nrdx - BC_NUM_RDX(n->scale - places) : 0;  in bc_num_truncate()
465 	assert(places <= n->scale && (BC_NUM_ZERO(n) || places_rdx <= n->len));  in bc_num_truncate()
467 	n->scale -= places;  in bc_num_truncate()
477 		pow = n->scale % BC_BASE_DIGS;  in bc_num_truncate()
502 		n->scale += places;  in bc_num_extend()
509 	places_rdx = BC_NUM_RDX(places + n->scale) - nrdx;  in bc_num_extend()
521 	n->scale += places;  in bc_num_extend()
524 	assert(BC_NUM_RDX_VAL(n) == BC_NUM_RDX(n->scale));  in bc_num_extend()
530 static void bc_num_retireMul(BcNum *restrict n, size_t scale,  in bc_num_retireMul()  argument
534 	if (n->scale < scale) bc_num_extend(n, scale - n->scale);  in bc_num_retireMul()
535 	else bc_num_truncate(n, n->scale - scale);  in bc_num_retireMul()
563 		a->scale = b->scale = 0;  in bc_num_split()
598 	r->scale = 0;  in bc_num_shiftRdx()
681 	if (places > n->scale) {  in bc_num_shiftLeft()
682 		size_t size = bc_vm_growSize(BC_NUM_RDX(places - n->scale), n->len);  in bc_num_shiftLeft()
688 		if (n->scale >= places) n->scale -= places;  in bc_num_shiftLeft()
689 		else n->scale = 0;  in bc_num_shiftLeft()
708 	if (n->scale) {  in bc_num_shiftLeft()
715 			size_t mod = n->scale % BC_BASE_DIGS, revdig;  in bc_num_shiftLeft()
740 	if (places > n->scale) {  in bc_num_shiftLeft()
741 		n->scale = 0;  in bc_num_shiftLeft()
745 		n->scale -= places;  in bc_num_shiftLeft()
746 		BC_NUM_RDX_SET(n, BC_NUM_RDX(n->scale));  in bc_num_shiftLeft()
758 	size_t places_rdx, scale, scale_mod, int_len, expand;  in bc_num_shiftRight()  local
765 		n->scale += places;  in bc_num_shiftRight()
766 		bc_num_expand(n, BC_NUM_RDX(n->scale));  in bc_num_shiftRight()
774 	scale = n->scale;  in bc_num_shiftRight()
777 	scale_mod = scale % BC_BASE_DIGS;  in bc_num_shiftRight()
805 	n->scale = 0;  in bc_num_shiftRight()
811 	n->scale = scale + places;  in bc_num_shiftRight()
812 	BC_NUM_RDX_SET(n, BC_NUM_RDX(n->scale));  in bc_num_shiftRight()
817 	assert(BC_NUM_RDX_VAL(n) == BC_NUM_RDX(n->scale));  in bc_num_shiftRight()
826 static inline void bc_num_inv(BcNum *a, BcNum *b, size_t scale) {  in bc_num_inv()  argument
828 	bc_num_div(&vm.one, a, b, scale);  in bc_num_inv()
1050 	c->scale = BC_MAX(a->scale, b->scale);  in bc_num_as()
1284 static void bc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale) {  in bc_num_m()  argument
1294 	ascale = a->scale;  in bc_num_m()
1295 	bscale = b->scale;  in bc_num_m()
1298 	scale = BC_MAX(scale, ascale);  in bc_num_m()
1299 	scale = BC_MAX(scale, bscale);  in bc_num_m()
1301 	scale = BC_MIN(rscale, scale);  in bc_num_m()
1394 	bc_num_retireMul(c, scale, BC_NUM_NEG(a), BC_NUM_NEG(b));  in bc_num_m()
1471                           BcNum *restrict c, size_t scale)  in bc_num_d_long()  argument
1492 	c->scale = a->scale;  in bc_num_d_long()
1544 	assert(c->scale >= scale);  in bc_num_d_long()
1545 	rdx = BC_NUM_RDX_VAL(c) - BC_NUM_RDX(scale);  in bc_num_d_long()
1628 static void bc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale) {  in bc_num_d()  argument
1636 		bc_num_setToZero(c, scale);  in bc_num_d()
1642 		bc_num_retireMul(c, scale, BC_NUM_NEG(a), BC_NUM_NEG(b));  in bc_num_d()
1647 	if (!BC_NUM_RDX_VAL(a) && !BC_NUM_RDX_VAL(b) && b->len == 1 && !scale) {  in bc_num_d()
1650 		bc_num_retireMul(c, scale, BC_NUM_NEG(a), BC_NUM_NEG(b));  in bc_num_d()
1654 	len = bc_num_divReq(a, b, scale);  in bc_num_d()
1679 	cpa.scale = cpardx * BC_BASE_DIGS;  in bc_num_d()
1682 	bc_num_extend(&cpa, b->scale);  in bc_num_d()
1683 	cpardx = BC_NUM_RDX_VAL_NP(cpa) - BC_NUM_RDX(b->scale);  in bc_num_d()
1685 	cpa.scale = cpardx * BC_BASE_DIGS;  in bc_num_d()
1688 	if (scale > cpa.scale) {  in bc_num_d()
1689 		bc_num_extend(&cpa, scale);  in bc_num_d()
1691 		cpa.scale = cpardx * BC_BASE_DIGS;  in bc_num_d()
1707 	cpb.scale = 0;  in bc_num_d()
1710 	bc_num_d_long(&cpa, &cpb, c, scale);  in bc_num_d()
1712 	bc_num_retireMul(c, scale, BC_NUM_NEG(a), BC_NUM_NEG(b));  in bc_num_d()
1734                      BcNum *restrict d, size_t scale, size_t ts)  in bc_num_r()  argument
1756 	bc_num_d(a, b, c, scale);  in bc_num_r()
1759 	if (scale) scale = ts + 1;  in bc_num_r()
1765 	bc_num_m(c, b, &temp, scale);  in bc_num_r()
1766 	bc_num_sub(a, &temp, d, scale);  in bc_num_r()
1769 	if (ts > d->scale && BC_NUM_NONZERO(d)) bc_num_extend(d, ts - d->scale);  in bc_num_r()
1789 static void bc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale) {  in bc_num_rem()  argument
1794 	ts = bc_vm_growSize(scale, b->scale);  in bc_num_rem()
1795 	ts = BC_MAX(ts, a->scale);  in bc_num_rem()
1806 	bc_num_r(a, b, &c1, c, scale, ts);  in bc_num_rem()
1821 static void bc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale) {  in bc_num_p()  argument
1837 		bc_num_setToZero(c, scale);  in bc_num_p()
1843 		else bc_num_inv(a, c, scale);  in bc_num_p()
1863 		size_t max = BC_MAX(scale, a->scale), scalepow;  in bc_num_p()
1864 		scalepow = bc_num_mulOverflow(a->scale, exp);  in bc_num_p()
1865 		scale = BC_MIN(scalepow, max);  in bc_num_p()
1870 	for (powrdx = a->scale; !(exp & 1); exp >>= 1) {  in bc_num_p()
1900 	if (neg) bc_num_inv(c, c, scale);  in bc_num_p()
1903 	if (c->scale > scale) bc_num_truncate(c, c->scale - scale);  in bc_num_p()
1921 static void bc_num_place(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale) {  in bc_num_place()  argument
1925 	BC_UNUSED(scale);  in bc_num_place()
1930 	if (val < c->scale) bc_num_truncate(c, c->scale - val);  in bc_num_place()
1931 	else if (val > c->scale) bc_num_extend(c, val - c->scale);  in bc_num_place()
1937 static void bc_num_left(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale) {  in bc_num_left()  argument
1941 	BC_UNUSED(scale);  in bc_num_left()
1951 static void bc_num_right(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale) {  in bc_num_right()  argument
1955 	BC_UNUSED(scale);  in bc_num_right()
1983 static void bc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,  in bc_num_binary()  argument
2043 	op(ptr_a, ptr_b, c, scale);  in bc_num_binary()
2169 	n->scale = (size_t) (rdx * (((uintptr_t) (val + len)) -  in bc_num_parseDecimal()
2173 	BC_NUM_RDX_SET(n, BC_NUM_RDX(n->scale));  in bc_num_parseDecimal()
2179 	mod = n->scale % BC_BASE_DIGS;  in bc_num_parseDecimal()
2347 		if (n->scale < digs) bc_num_extend(n, digs - n->scale);  in bc_num_parseBase()
2487 		temp = n->scale % BC_BASE_DIGS;  in bc_num_printDecimal()
2803 	bc_num_truncate(&intp, intp.scale);  in bc_num_printNum()
2881 		      (n->scale != 0 || i == stack.len - 1));  in bc_num_printNum()
2885 	if (!n->scale) goto err;  in bc_num_printNum()
2909 	fracp2.scale = n->scale;  in bc_num_printNum()
2910 	BC_NUM_RDX_SET_NP(fracp2, BC_NUM_RDX(fracp2.scale));  in bc_num_printNum()
2913 	while ((idigits = bc_num_intDigits(n1)) <= n->scale) {  in bc_num_printNum()
2936 		print(dig, len, radix, !newline || idigits != n->scale);  in bc_num_printNum()
3061 	d->scale = s->scale;  in bc_num_copy()
3078 	return n->scale;  in bc_num_scale()
3086 	if (BC_NUM_ZERO(n)) return n->scale ? n->scale : 1;  in bc_num_len()
3095 		size_t zero, scale;  in bc_num_len()  local
3101 		scale = n->scale % BC_BASE_DIGS;  in bc_num_len()
3102 		scale = scale ? scale : BC_BASE_DIGS;  in bc_num_len()
3108 		len = len * BC_BASE_DIGS - zero - (BC_BASE_DIGS - scale);  in bc_num_len()
3111 	else len = bc_num_intDigits(n) + n->scale;  in bc_num_len()
3275 	frac.scale = n->scale;  in bc_num_rng()
3283 	bc_num_truncate(&temp, temp.scale);  in bc_num_rng()
3449 size_t bc_num_addReq(const BcNum *a, const BcNum *b, size_t scale) {  in bc_num_addReq()  argument
3456 	BC_UNUSED(scale);  in bc_num_addReq()
3472 size_t bc_num_mulReq(const BcNum *a, const BcNum *b, size_t scale) {  in bc_num_mulReq()  argument
3480 	max = BC_NUM_RDX(scale);  in bc_num_mulReq()
3488 size_t bc_num_divReq(const BcNum *a, const BcNum *b, size_t scale) {  in bc_num_divReq()  argument
3496 	max = BC_NUM_RDX(scale);  in bc_num_divReq()
3504 size_t bc_num_powReq(const BcNum *a, const BcNum *b, size_t scale) {  in bc_num_powReq()  argument
3505 	BC_UNUSED(scale);  in bc_num_powReq()
3510 size_t bc_num_placesReq(const BcNum *a, const BcNum *b, size_t scale) {  in bc_num_placesReq()  argument
3511 	BC_UNUSED(scale);  in bc_num_placesReq()
3516 void bc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_add()  argument
3519 	bc_num_binary(a, b, c, false, bc_num_as, bc_num_addReq(a, b, scale));  in bc_num_add()
3522 void bc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_sub()  argument
3525 	bc_num_binary(a, b, c, true, bc_num_as, bc_num_addReq(a, b, scale));  in bc_num_sub()
3528 void bc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_mul()  argument
3531 	bc_num_binary(a, b, c, scale, bc_num_m, bc_num_mulReq(a, b, scale));  in bc_num_mul()
3534 void bc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_div()  argument
3537 	bc_num_binary(a, b, c, scale, bc_num_d, bc_num_divReq(a, b, scale));  in bc_num_div()
3540 void bc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_mod()  argument
3543 	bc_num_binary(a, b, c, scale, bc_num_rem, bc_num_divReq(a, b, scale));  in bc_num_mod()
3546 void bc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_pow()  argument
3549 	bc_num_binary(a, b, c, scale, bc_num_p, bc_num_powReq(a, b, scale));  in bc_num_pow()
3553 void bc_num_places(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_places()  argument
3556 	bc_num_binary(a, b, c, scale, bc_num_place, bc_num_placesReq(a, b, scale));  in bc_num_places()
3559 void bc_num_lshift(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_lshift()  argument
3562 	bc_num_binary(a, b, c, scale, bc_num_left, bc_num_placesReq(a, b, scale));  in bc_num_lshift()
3565 void bc_num_rshift(BcNum *a, BcNum *b, BcNum *c, size_t scale) {  in bc_num_rshift()  argument
3568 	bc_num_binary(a, b, c, scale, bc_num_right, bc_num_placesReq(a, b, scale));  in bc_num_rshift()
3572 void bc_num_sqrt(BcNum *restrict a, BcNum *restrict b, size_t scale) {  in bc_num_sqrt()  argument
3584 	if (a->scale > scale) scale = a->scale;  in bc_num_sqrt()
3588 	rdx = BC_NUM_RDX(scale);  in bc_num_sqrt()
3607 		bc_num_setToZero(b, scale);  in bc_num_sqrt()
3614 		bc_num_extend(b, scale);  in bc_num_sqrt()
3619 	rdx = BC_NUM_RDX(scale);  in bc_num_sqrt()
3635 	half.scale = 1;  in bc_num_sqrt()
3669 	x0->scale = x0->rdx = 0;  in bc_num_sqrt()
3670 	resscale = (scale + BC_BASE_DIGS) + 2;  in bc_num_sqrt()
3697 	if (b->scale > scale) bc_num_truncate(b, b->scale - scale);  in bc_num_sqrt()
3713 void bc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d, size_t scale) {  in bc_num_divmod()  argument
3723 	ts = BC_MAX(scale + b->scale, a->scale);  in bc_num_divmod()
3752 	    !BC_NUM_RDX_VAL(b) && b->len == 1 && !scale)  in bc_num_divmod()
3764 	else bc_num_r(ptr_a, b, c, d, scale, ts);  in bc_num_divmod()
3891 	               name, n->len, BC_NUM_RDX_VAL(n), n->scale);  in bc_num_printWithDigs()
3897 	ulong i, scale = n->scale;  in bc_num_dump()  local
3907 		if (scale / BC_BASE_DIGS != BC_NUM_RDX_VAL(n) - i - 1)  in bc_num_dump()
3911 			int mod = scale % BC_BASE_DIGS;  in bc_num_dump()
3926 	               n->scale, n->len, BC_NUM_RDX_VAL(n), n->cap,  in bc_num_dump()