55 bc_num_m(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale);
129  * Set a number to 0 with the specified scale.
131  * @param scale  The scale to set the number to.
134 bc_num_setToZero(BcNum* restrict n, size_t scale)  in bc_num_setToZero()  argument
137 	n->scale = scale;  in bc_num_setToZero()
219  * by to put its digits in the right place. For example, if the scale only
222  * @param scale  The scale.
227 bc_num_leastSigPow(size_t scale)  in bc_num_leastSigPow()  argument
231 	digs = scale % BC_BASE_DIGS;  in bc_num_leastSigPow()
239  * of scale, like bc_num_int() is the opposite of rdx.
585 	// rdx is to scale.  in bc_num_truncate()
587 	places_rdx = nrdx ? nrdx - BC_NUM_RDX(n->scale - places) : 0;  in bc_num_truncate()
590 	assert(places <= n->scale && (BC_NUM_ZERO(n) || places_rdx <= n->len));  in bc_num_truncate()
592 	n->scale -= places;  in bc_num_truncate()
602 		pow = bc_num_leastSigPow(n->scale);  in bc_num_truncate()
625 	// Easy case with zero; set the scale.  in bc_num_extend()
628 		n->scale += places;  in bc_num_extend()
633 	// rdx is to scale.  in bc_num_extend()
635 	places_rdx = BC_NUM_RDX(places + n->scale) - nrdx;  in bc_num_extend()
648 	// Finally, set scale and rdx.  in bc_num_extend()
650 	n->scale += places;  in bc_num_extend()
653 	assert(BC_NUM_RDX_VAL(n) == BC_NUM_RDX(n->scale));  in bc_num_extend()
660 bc_num_retireMul(BcNum* restrict n, size_t scale, bool neg1, bool neg2)  in bc_num_retireMul()  argument
662 	// Make sure scale is correct.  in bc_num_retireMul()
663 	if (n->scale < scale) bc_num_extend(n, scale - n->scale);  in bc_num_retireMul()
664 	else bc_num_truncate(n, n->scale - scale);  in bc_num_retireMul()
693 		a->scale = b->scale = 0;  in bc_num_split()
731 	r->scale = 0;  in bc_num_shiftRdx()
825 	if (places > n->scale)  in bc_num_shiftLeft()
827 		size_t size = bc_vm_growSize(BC_NUM_RDX(places - n->scale), n->len);  in bc_num_shiftLeft()
831 	// If zero, we can just set the scale and bail.  in bc_num_shiftLeft()
834 		if (n->scale >= places) n->scale -= places;  in bc_num_shiftLeft()
835 		else n->scale = 0;  in bc_num_shiftLeft()
854 	if (n->scale)  in bc_num_shiftLeft()
861 			size_t mod = n->scale % BC_BASE_DIGS, revdig;  in bc_num_shiftLeft()
888 	// Set the scale appropriately.  in bc_num_shiftLeft()
889 	if (places > n->scale)  in bc_num_shiftLeft()
891 		n->scale = 0;  in bc_num_shiftLeft()
896 		n->scale -= places;  in bc_num_shiftLeft()
897 		BC_NUM_RDX_SET(n, BC_NUM_RDX(n->scale));  in bc_num_shiftLeft()
910 	size_t places_rdx, scale, scale_mod, int_len, expand;  in bc_num_shiftRight()  local
915 	// If zero, we can just set the scale and bail.  in bc_num_shiftRight()
918 		n->scale += places;  in bc_num_shiftRight()
919 		bc_num_expand(n, BC_NUM_RDX(n->scale));  in bc_num_shiftRight()
927 	scale = n->scale;  in bc_num_shiftRight()
929 	// Figure out how the scale is affected.  in bc_num_shiftRight()
930 	scale_mod = scale % BC_BASE_DIGS;  in bc_num_shiftRight()
961 	n->scale = 0;  in bc_num_shiftRight()
967 	n->scale = scale + places;  in bc_num_shiftRight()
968 	BC_NUM_RDX_SET(n, BC_NUM_RDX(n->scale));  in bc_num_shiftRight()
973 	assert(BC_NUM_RDX_VAL(n) == BC_NUM_RDX(n->scale));  in bc_num_shiftRight()
977  * Tests if a number is a integer with scale or not. Returns true if the number
1043  * doesn't need to use scale (per the bc spec), I am hijacking it to say whether
1231 	c->scale = BC_MAX(a->scale, b->scale);  in bc_num_as()
1238  * numbers gets low enough. This doesn't use scale because it treats the
1479  * @param scale  The current scale.
1482 bc_num_m(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale)  in bc_num_m()  argument
1502 	ascale = a->scale;  in bc_num_m()
1503 	bscale = b->scale;  in bc_num_m()
1505 	// This sets the final scale according to the bc spec.  in bc_num_m()
1506 	scale1 = BC_MAX(scale, ascale);  in bc_num_m()
1594 	// The return parameter needs to have its scale set. This is the start. It  in bc_num_m()
1690  * @param scale  The current scale.
1694               size_t scale)  in bc_num_d_long()  argument
1730 	c->scale = a->scale;  in bc_num_d_long()
1793 	assert(c->scale >= scale);  in bc_num_d_long()
1794 	rdx = BC_NUM_RDX_VAL(c) - BC_NUM_RDX(scale);  in bc_num_d_long()
1876  * @param scale  The current scale.
1879 bc_num_d(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale)  in bc_num_d()  argument
1891 		bc_num_setToZero(c, scale);  in bc_num_d()
1898 		bc_num_retireMul(c, scale, BC_NUM_NEG(a), BC_NUM_NEG(b));  in bc_num_d()
1903 	if (!BC_NUM_RDX_VAL(a) && !BC_NUM_RDX_VAL(b) && b->len == 1 && !scale)  in bc_num_d()
1907 		bc_num_retireMul(c, scale, BC_NUM_NEG(a), BC_NUM_NEG(b));  in bc_num_d()
1911 	len = bc_num_divReq(a, b, scale);  in bc_num_d()
1937 	cpa.scale = cpardx * BC_BASE_DIGS;  in bc_num_d()
1939 	// This is just setting up the scale in preparation for the division.  in bc_num_d()
1940 	bc_num_extend(&cpa, b->scale);  in bc_num_d()
1941 	cpardx = BC_NUM_RDX_VAL_NP(cpa) - BC_NUM_RDX(b->scale);  in bc_num_d()
1943 	cpa.scale = cpardx * BC_BASE_DIGS;  in bc_num_d()
1945 	// Once again, just setting things up, this time to match scale.  in bc_num_d()
1946 	if (scale > cpa.scale)  in bc_num_d()
1948 		bc_num_extend(&cpa, scale);  in bc_num_d()
1950 		cpa.scale = cpardx * BC_BASE_DIGS;  in bc_num_d()
1969 	cpb.scale = 0;  in bc_num_d()
1972 	bc_num_d_long(&cpa, &cpb, c, scale);  in bc_num_d()
1974 	bc_num_retireMul(c, scale, BC_NUM_NEG(a), BC_NUM_NEG(b));  in bc_num_d()
1991  * @param scale  The current scale.
1992  * @param ts     The scale that the operation should be done to. Yes, it's not
1993  *               necessarily the same as scale, per the bc spec.
1996 bc_num_r(BcNum* a, BcNum* b, BcNum* restrict c, BcNum* restrict d, size_t scale,  in bc_num_r()  argument
2026 	bc_num_d(a, b, c, scale);  in bc_num_r()
2029 	if (scale) realscale = ts + 1;  in bc_num_r()
2030 	else realscale = scale;  in bc_num_r()
2040 	if (ts > d->scale && BC_NUM_NONZERO(d)) bc_num_extend(d, ts - d->scale);  in bc_num_r()
2058  * @param scale  The current scale.
2061 bc_num_rem(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale)  in bc_num_rem()  argument
2069 	ts = bc_vm_growSize(scale, b->scale);  in bc_num_rem()
2070 	ts = BC_MAX(ts, a->scale);  in bc_num_rem()
2081 	bc_num_r(a, b, &c1, c, scale, ts);  in bc_num_rem()
2094  * @param scale  The current scale.
2097 bc_num_p(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale)  in bc_num_p()  argument
2129 		bc_num_setToZero(c, scale);  in bc_num_p()
2136 		else bc_num_inv(a, c, scale);  in bc_num_p()
2154 	// set scale accordingly.  in bc_num_p()
2157 		size_t max = BC_MAX(scale, a->scale), scalepow;  in bc_num_p()
2158 		scalepow = bc_num_mulOverflow(a->scale, exp);  in bc_num_p()
2161 	else realscale = scale;  in bc_num_p()
2165 	for (powrdx = a->scale; !(exp & 1); exp >>= 1)  in bc_num_p()
2200 	if (c->scale > realscale) bc_num_truncate(c, c->scale - realscale);  in bc_num_p()
2216  * @param scale  The current scale.
2219 bc_num_place(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale)  in bc_num_place()  argument
2223 	BC_UNUSED(scale);  in bc_num_place()
2228 	if (val < c->scale) bc_num_truncate(c, c->scale - val);  in bc_num_place()
2229 	else if (val > c->scale) bc_num_extend(c, val - c->scale);  in bc_num_place()
2236 bc_num_left(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale)  in bc_num_left()  argument
2240 	BC_UNUSED(scale);  in bc_num_left()
2251 bc_num_right(BcNum* a, BcNum* b, BcNum* restrict c, size_t scale)  in bc_num_right()  argument
2255 	BC_UNUSED(scale);  in bc_num_right()
2280  * @param scale  The current scale.
2284 bc_num_binary(BcNum* a, BcNum* b, BcNum* c, size_t scale, BcNumBinOp op,  in bc_num_binary()  argument
2333 	op(ptr_a, ptr_b, c, scale);  in bc_num_binary()
2473 	// Set the scale of the number based on the location of the decimal point.  in bc_num_parseDecimal()
2476 	n->scale = (size_t) (rdx *  in bc_num_parseDecimal()
2480 	BC_NUM_RDX_SET(n, BC_NUM_RDX(n->scale));  in bc_num_parseDecimal()
2486 	mod = n->scale % BC_BASE_DIGS;  in bc_num_parseDecimal()
2695 		if (n->scale < digs) bc_num_extend(n, digs - n->scale);  in bc_num_parseBase()
2848 		temp = n->scale % BC_BASE_DIGS;  in bc_num_printDecimal()
3113 	// Easy case. Even with scale, we just print this.  in bc_num_printNum()
3174 	bc_num_truncate(&intp, intp.scale);  in bc_num_printNum()
3261 		// If the number has a scale, then because we are printing just the  in bc_num_printNum()
3263 		// point plus at least one digit). So if there is a scale, a backslash  in bc_num_printNum()
3276 		      !newline || (n->scale != 0 || i < stack.len - 1));  in bc_num_printNum()
3280 	if (!n->scale) goto err;  in bc_num_printNum()
3304 	fracp2.scale = n->scale;  in bc_num_printNum()
3305 	BC_NUM_RDX_SET_NP(fracp2, BC_NUM_RDX(fracp2.scale));  in bc_num_printNum()
3307 	// As long as we have not reached the scale of the number, keep printing.  in bc_num_printNum()
3308 	while ((idigits = bc_num_intDigits(n1)) <= n->scale)  in bc_num_printNum()
3331 		print(dig, len, radix, !newline || idigits != n->scale);  in bc_num_printNum()
3472 	d->scale = s->scale;  in bc_num_copy()
3496 	return n->scale;  in bc_num_scale()
3505 	if (BC_NUM_ZERO(n)) return n->scale ? n->scale : 1;  in bc_num_len()
3514 		size_t zero, scale;  in bc_num_len()  local
3520 		scale = n->scale % BC_BASE_DIGS;  in bc_num_len()
3521 		scale = scale ? scale : BC_BASE_DIGS;  in bc_num_len()
3527 		len = len * BC_BASE_DIGS - zero - (BC_BASE_DIGS - scale);  in bc_num_len()
3529 	// Otherwise, count the number of int digits and return that plus the scale.  in bc_num_len()
3530 	else len = bc_num_intDigits(n) + n->scale;  in bc_num_len()
3734 	frac.scale = n->scale;  in bc_num_rng()
3742 	bc_num_truncate(&temp, temp.scale);  in bc_num_rng()
3978 bc_num_addReq(const BcNum* a, const BcNum* b, size_t scale)  in bc_num_addReq()  argument
3985 	BC_UNUSED(scale);  in bc_num_addReq()
4002 bc_num_mulReq(const BcNum* a, const BcNum* b, size_t scale)  in bc_num_mulReq()  argument
4010 	max = BC_NUM_RDX(scale);  in bc_num_mulReq()
4019 bc_num_divReq(const BcNum* a, const BcNum* b, size_t scale)  in bc_num_divReq()  argument
4023 	// Division requires the length of the dividend plus the scale.  in bc_num_divReq()
4027 	max = BC_NUM_RDX(scale);  in bc_num_divReq()
4036 bc_num_powReq(const BcNum* a, const BcNum* b, size_t scale)  in bc_num_powReq()  argument
4038 	BC_UNUSED(scale);  in bc_num_powReq()
4044 bc_num_placesReq(const BcNum* a, const BcNum* b, size_t scale)  in bc_num_placesReq()  argument
4046 	BC_UNUSED(scale);  in bc_num_placesReq()
4052 bc_num_add(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_add()  argument
4056 	bc_num_binary(a, b, c, false, bc_num_as, bc_num_addReq(a, b, scale));  in bc_num_add()
4060 bc_num_sub(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_sub()  argument
4064 	bc_num_binary(a, b, c, true, bc_num_as, bc_num_addReq(a, b, scale));  in bc_num_sub()
4068 bc_num_mul(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_mul()  argument
4072 	bc_num_binary(a, b, c, scale, bc_num_m, bc_num_mulReq(a, b, scale));  in bc_num_mul()
4076 bc_num_div(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_div()  argument
4080 	bc_num_binary(a, b, c, scale, bc_num_d, bc_num_divReq(a, b, scale));  in bc_num_div()
4084 bc_num_mod(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_mod()  argument
4088 	bc_num_binary(a, b, c, scale, bc_num_rem, bc_num_divReq(a, b, scale));  in bc_num_mod()
4092 bc_num_pow(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_pow()  argument
4096 	bc_num_binary(a, b, c, scale, bc_num_p, bc_num_powReq(a, b, scale));  in bc_num_pow()
4101 bc_num_places(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_places()  argument
4105 	bc_num_binary(a, b, c, scale, bc_num_place, bc_num_placesReq(a, b, scale));  in bc_num_places()
4109 bc_num_lshift(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_lshift()  argument
4113 	bc_num_binary(a, b, c, scale, bc_num_left, bc_num_placesReq(a, b, scale));  in bc_num_lshift()
4117 bc_num_rshift(BcNum* a, BcNum* b, BcNum* c, size_t scale)  in bc_num_rshift()  argument
4121 	bc_num_binary(a, b, c, scale, bc_num_right, bc_num_placesReq(a, b, scale));  in bc_num_rshift()
4126 bc_num_sqrt(BcNum* restrict a, BcNum* restrict b, size_t scale)  in bc_num_sqrt()  argument
4144 	// We want to calculate to a's scale if it is bigger so that the result will  in bc_num_sqrt()
4146 	if (a->scale > scale) realscale = a->scale;  in bc_num_sqrt()
4147 	else realscale = scale;  in bc_num_sqrt()
4235 	x0->scale = x0->rdx = 0;  in bc_num_sqrt()
4263 	if (b->scale > realscale) bc_num_truncate(b, b->scale - realscale);  in bc_num_sqrt()
4280 bc_num_divmod(BcNum* a, BcNum* b, BcNum* c, BcNum* d, size_t scale)  in bc_num_divmod()  argument
4295 	ts = BC_MAX(scale + b->scale, a->scale);  in bc_num_divmod()
4326 	    b->len == 1 && !scale)  in bc_num_divmod()
4338 	else bc_num_r(ptr_a, b, c, d, scale, ts);  in bc_num_divmod()
4475 	bc_file_printf(&vm->fout, " len: %zu, rdx: %zu, scale: %zu\n", name, n->len,  in bc_num_printWithDigs()
4476 	               BC_NUM_RDX_VAL(n), n->scale);  in bc_num_printWithDigs()
4483 	ulong i, scale = n->scale;  in bc_num_dump()  local
4495 		if (scale / BC_BASE_DIGS != BC_NUM_RDX_VAL(n) - i - 1)  in bc_num_dump()
4501 			int mod = scale % BC_BASE_DIGS;  in bc_num_dump()
4516 	bc_file_printf(&vm->ferr, "(%zu | %zu.%zu / %zu) %lu\n", n->scale, n->len,  in bc_num_dump()