def test_lt(self):
val = [0, 0x111111111111, 0x111111111112, 0x111111111112FFFF]
for x in gen_signs(val):
for y in gen_signs(val):
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
assert (x < y) == f1.lt(f2)
def test_lt(self):
val = [0, 0x111111111111, 0x111111111112, 0x111111111112FFFF]
for x in gen_signs(val):
for y in gen_signs(val):
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
assert (x < y) == f1.lt(f2)
def test_pow_lln(self):
x = 10L
y = 2L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
v = f1.pow(f2)
assert v.tolong() == x ** y
def test_pow_lln(self):
x = 10L
y = 2L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
v = f1.pow(f2)
assert v.tolong() == x ** y
def test_parse_digit_string(self):
from pypy.rlib.rbigint import parse_digit_string
class Parser:
def __init__(self, base, sign, digits):
self.base = base
self.sign = sign
self.next_digit = iter(digits + [-1]).next
x = parse_digit_string(Parser(10, 1, [6]))
assert x.eq(rbigint.fromint(6))
x = parse_digit_string(Parser(10, 1, [6, 2, 3]))
assert x.eq(rbigint.fromint(623))
x = parse_digit_string(Parser(10, -1, [6, 2, 3]))
assert x.eq(rbigint.fromint(-623))
x = parse_digit_string(Parser(16, 1, [0xA, 0x4, 0xF]))
assert x.eq(rbigint.fromint(0xA4F))
num = 0
for i in range(36):
x = parse_digit_string(Parser(36, 1, range(i)))
assert x.eq(rbigint.fromlong(num))
num = num * 36 + i
x = parse_digit_string(Parser(16, -1, range(15,-1,-1)*99))
assert x.eq(rbigint.fromlong(long('-0x' + 'FEDCBA9876543210'*99, 16)))
assert x.tobool() is True
x = parse_digit_string(Parser(7, 1, [0, 0, 0]))
assert x.tobool() is False
x = parse_digit_string(Parser(7, -1, [0, 0, 0]))
assert x.tobool() is False
def test_str(self):
for i in range(100):
n = 3 ** i
r1 = rbigint.fromlong(n)
assert r1.str() == str(n)
r2 = rbigint.fromlong(-n)
assert r2.str() == str(-n)
def test_ulonglongmask(self):
assert rbigint.fromlong(-1).ulonglongmask() == r_ulonglong(-1)
assert rbigint.fromlong(0).ulonglongmask() == r_ulonglong(0)
assert (rbigint.fromlong(sys.maxint).ulonglongmask() == r_ulonglong(
sys.maxint))
assert (rbigint.fromlong(9**50).ulonglongmask() == r_ulonglong(9**50))
assert (
rbigint.fromlong(-9**50).ulonglongmask() == r_ulonglong(-9**50))
def test_tofloat(self):
x = 12345678901234567890L**10
f1 = rbigint.fromlong(x)
d = f1.tofloat()
assert d == float(x)
x = x**100
f1 = rbigint.fromlong(x)
assert raises(OverflowError, f1.tofloat)
def test_tofloat(self):
x = 12345678901234567890L ** 10
f1 = rbigint.fromlong(x)
d = f1.tofloat()
assert d == float(x)
x = x ** 100
f1 = rbigint.fromlong(x)
assert raises(OverflowError, f1.tofloat)
def test_invert(self):
x = 3 ** 40
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(-x)
r1 = f1.invert()
r2 = f2.invert()
assert r1.tolong() == -(x + 1)
assert r2.tolong() == -(-x + 1)
def test_invert(self):
x = 3 ** 40
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(-x)
r1 = f1.invert()
r2 = f2.invert()
assert r1.tolong() == -(x + 1)
assert r2.tolong() == -(-x + 1)
def test_truediv_overflow2(self):
overflowing = 2**1024 - 2**(1024-53-1)
op1 = rbigint.fromlong(2*overflowing - 10)
op2 = rbigint.fromlong(2)
f = op1.truediv(op2)
assert f == 1.7976931348623157e+308 # exactly
op2 = rbigint.fromlong(-2)
f = op1.truediv(op2)
assert f == -1.7976931348623157e+308 # exactly
def test_bitwise(self):
for x in gen_signs([0, 1, 5, 11, 42, 43, 3 ** 30]):
for y in gen_signs([0, 1, 5, 11, 42, 43, 3 ** 30, 3 ** 31]):
lx = rbigint.fromlong(x)
ly = rbigint.fromlong(y)
for mod in "xor and_ or_".split():
res1 = getattr(lx, mod)(ly).tolong()
res2 = getattr(operator, mod)(x, y)
assert res1 == res2
def test_ulonglongmask(self):
assert rbigint.fromlong(-1).ulonglongmask() == r_ulonglong(-1)
assert rbigint.fromlong(0).ulonglongmask() == r_ulonglong(0)
assert (rbigint.fromlong(sys.maxint).ulonglongmask() ==
r_ulonglong(sys.maxint))
assert (rbigint.fromlong(9**50).ulonglongmask() ==
r_ulonglong(9**50))
assert (rbigint.fromlong(-9**50).ulonglongmask() ==
r_ulonglong(-9**50))
def test_add(self):
x = 123456789123456789000000L
y = 123858582373821923936744221L
for i in [-1, 1]:
for j in [-1, 1]:
f1 = rbigint.fromlong(x * i)
f2 = rbigint.fromlong(y * j)
result = f1.add(f2)
assert result.tolong() == x * i + y * j
def test_sub(self):
x = 12378959520302182384345L
y = 88961284756491823819191823L
for i in [-1, 1]:
for j in [-1, 1]:
f1 = rbigint.fromlong(x * i)
f2 = rbigint.fromlong(y * j)
result = f1.sub(f2)
assert result.tolong() == x * i - y * j
def test_bitwise(self):
for x in gen_signs([0, 1, 5, 11, 42, 43, 3 ** 30]):
for y in gen_signs([0, 1, 5, 11, 42, 43, 3 ** 30, 3 ** 31]):
lx = rbigint.fromlong(x)
ly = rbigint.fromlong(y)
for mod in "xor and_ or_".split():
res1 = getattr(lx, mod)(ly).tolong()
res2 = getattr(operator, mod)(x, y)
assert res1 == res2
def test_sub(self):
x = 12378959520302182384345L
y = 88961284756491823819191823L
for i in [-1, 1]:
for j in [-1, 1]:
f1 = rbigint.fromlong(x * i)
f2 = rbigint.fromlong(y * j)
result = f1.sub(f2)
assert result.tolong() == x * i - y * j
def test_add(self):
x = 123456789123456789000000L
y = 123858582373821923936744221L
for i in [-1, 1]:
for j in [-1, 1]:
f1 = rbigint.fromlong(x * i)
f2 = rbigint.fromlong(y * j)
result = f1.add(f2)
assert result.tolong() == x * i + y * j
def test_mul(self):
x = -1238585838347L
y = 585839391919233L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
result = f1.mul(f2)
assert result.tolong() == x * y
# also test a * a, it has special code
result = f1.mul(f1)
assert result.tolong() == x * x
def test_longlong(self):
max = 1L << (r_longlong.BITS-1)
f1 = rbigint.fromlong(max-1) # fits in r_longlong
f2 = rbigint.fromlong(-max) # fits in r_longlong
f3 = rbigint.fromlong(max) # overflows
f4 = rbigint.fromlong(-max-1) # overflows
assert f1.tolonglong() == max-1
assert f2.tolonglong() == -max
py.test.raises(OverflowError, f3.tolonglong)
py.test.raises(OverflowError, f4.tolonglong)
def test_mul(self):
x = -1238585838347L
y = 585839391919233L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
result = f1.mul(f2)
assert result.tolong() == x * y
# also test a * a, it has special code
result = f1.mul(f1)
assert result.tolong() == x * x
def test__x_divrem(self):
x = 12345678901234567890L
for i in range(100):
y = long(randint(0, 1 << 30))
y <<= 30
y += randint(0, 1 << 30)
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
div, rem = lobj._x_divrem(f1, f2)
assert div.tolong(), rem.tolong() == divmod(x, y)
def test__x_divrem(self):
x = 12345678901234567890L
for i in range(100):
y = long(randint(0, 1 << 30))
y <<= 30
y += randint(0, 1 << 30)
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
div, rem = lobj._x_divrem(f1, f2)
assert div.tolong(), rem.tolong() == divmod(x, y)
def test_longlong(self):
max = 1L << (r_longlong.BITS-1)
f1 = rbigint.fromlong(max-1) # fits in r_longlong
f2 = rbigint.fromlong(-max) # fits in r_longlong
f3 = rbigint.fromlong(max) # overflows
f4 = rbigint.fromlong(-max-1) # overflows
assert f1.tolonglong() == max-1
assert f2.tolonglong() == -max
py.test.raises(OverflowError, f3.tolonglong)
py.test.raises(OverflowError, f4.tolonglong)
def test_int_conversion(self):
f1 = rbigint.fromlong(12332)
f2 = rbigint.fromint(12332)
assert f2.tolong() == f1.tolong()
assert f2.toint()
assert rbigint.fromlong(42).tolong() == 42
assert rbigint.fromlong(-42).tolong() == -42
u = f2.touint()
assert u == 12332
assert type(u) is r_uint
def test_eq(self):
x = 5858393919192332223L
y = 585839391919233111223311112332L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(-x)
f3 = rbigint.fromlong(y)
assert f1.eq(f1)
assert f2.eq(f2)
assert f3.eq(f3)
assert not f1.eq(f2)
assert not f1.eq(f3)
def test_eq(self):
x = 5858393919192332223L
y = 585839391919233111223311112332L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(-x)
f3 = rbigint.fromlong(y)
assert f1.eq(f1)
assert f2.eq(f2)
assert f3.eq(f3)
assert not f1.eq(f2)
assert not f1.eq(f3)
def test_int_conversion(self):
f1 = rbigint.fromlong(12332)
f2 = rbigint.fromint(12332)
assert f2.tolong() == f1.tolong()
assert f2.toint()
assert rbigint.fromlong(42).tolong() == 42
assert rbigint.fromlong(-42).tolong() == -42
u = f2.touint()
assert u == 12332
assert type(u) is r_uint
def test_tofloat(self):
x = 12345678901234567890L ** 10
f1 = rbigint.fromlong(x)
d = f1.tofloat()
assert d == float(x)
x = x ** 100
f1 = rbigint.fromlong(x)
assert raises(OverflowError, f1.tofloat)
f2 = rbigint([0, 2097152], 1)
d = f2.tofloat()
assert d == float(2097152 << SHIFT)
def test_pow_lll(self):
x = 10L
y = 2L
z = 13L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
f3 = rbigint.fromlong(z)
v = f1.pow(f2, f3)
assert v.tolong() == pow(x, y, z)
f1, f2, f3 = [rbigint.fromlong(i) for i in (10L, -1L, 42L)]
py.test.raises(TypeError, f1.pow, f2, f3)
f1, f2, f3 = [rbigint.fromlong(i) for i in (10L, 5L, 0L)]
py.test.raises(ValueError, f1.pow, f2, f3)
def test_args_from_uint(self):
BASE = 1 << SHIFT
assert rbigint.fromrarith_int(r_uint(0)).eq(rbigint([0], 0))
assert rbigint.fromrarith_int(r_uint(17)).eq(rbigint([17], 1))
assert rbigint.fromrarith_int(r_uint(BASE-1)).eq(rbigint([BASE-1], 1))
assert rbigint.fromrarith_int(r_uint(BASE)).eq(rbigint([0, 1], 1))
assert rbigint.fromrarith_int(r_uint(BASE**2)).eq(rbigint([0, 0, 1], 1))
assert rbigint.fromrarith_int(r_uint(sys.maxint)).eq(
rbigint.fromint(sys.maxint))
assert rbigint.fromrarith_int(r_uint(sys.maxint+1)).eq(
rbigint.fromlong(sys.maxint+1))
assert rbigint.fromrarith_int(r_uint(2*sys.maxint+1)).eq(
rbigint.fromlong(2*sys.maxint+1))
def test_args_from_uint(self):
BASE = 1 << SHIFT
assert rbigint.fromrarith_int(r_uint(0)).eq(bigint([0], 0))
assert rbigint.fromrarith_int(r_uint(17)).eq(bigint([17], 1))
assert rbigint.fromrarith_int(r_uint(BASE-1)).eq(bigint([intmask(BASE-1)], 1))
assert rbigint.fromrarith_int(r_uint(BASE)).eq(bigint([0, 1], 1))
#assert rbigint.fromrarith_int(r_uint(BASE**2)).eq(bigint([0], 0))
assert rbigint.fromrarith_int(r_uint(sys.maxint)).eq(
rbigint.fromint(sys.maxint))
assert rbigint.fromrarith_int(r_uint(sys.maxint+1)).eq(
rbigint.fromlong(sys.maxint+1))
assert rbigint.fromrarith_int(r_uint(2*sys.maxint+1)).eq(
rbigint.fromlong(2*sys.maxint+1))
def test__divrem(self):
x = 12345678901234567890L
for i in range(100):
y = long(randint(0, 1 << 30))
y <<= 30
y += randint(0, 1 << 30)
for sx, sy in (1, 1), (1, -1), (-1, -1), (-1, 1):
sx *= x
sy *= y
f1 = rbigint.fromlong(sx)
f2 = rbigint.fromlong(sy)
div, rem = lobj._x_divrem(f1, f2)
assert div.tolong(), rem.tolong() == divmod(sx, sy)
def test__divrem(self):
x = 12345678901234567890L
for i in range(100):
y = long(randint(0, 1 << 30))
y <<= 30
y += randint(0, 1 << 30)
for sx, sy in (1, 1), (1, -1), (-1, -1), (-1, 1):
sx *= x
sy *= y
f1 = rbigint.fromlong(sx)
f2 = rbigint.fromlong(sy)
div, rem = lobj._x_divrem(f1, f2)
assert div.tolong(), rem.tolong() == divmod(sx, sy)
def test_pow_lll(self):
x = 10L
y = 2L
z = 13L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
f3 = rbigint.fromlong(z)
v = f1.pow(f2, f3)
assert v.tolong() == pow(x, y, z)
f3n = f3.neg()
v = f1.pow(f2, f3n)
assert v.tolong() == pow(x, y, -z)
#
f1, f2, f3 = [rbigint.fromlong(i)
for i in (10L, -1L, 42L)]
py.test.raises(TypeError, f1.pow, f2, f3)
f1, f2, f3 = [rbigint.fromlong(i)
for i in (10L, 5L, 0L)]
py.test.raises(ValueError, f1.pow, f2, f3)
#
MAX = 1E40
x = long(random() * MAX) + 1
y = long(random() * MAX) + 1
z = long(random() * MAX) + 1
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
f3 = rbigint.fromlong(z)
print f1
print f2
print f3
v = f1.pow(f2, f3)
print '--->', v
assert v.tolong() == pow(x, y, z)
def test_tostring(self):
z = rbigint.fromlong(0)
assert z.str() == '0'
assert z.repr() == '0L'
assert z.hex() == '0x0L'
assert z.oct() == '0L'
x = rbigint.fromlong(-18471379832321)
assert x.str() == '-18471379832321'
assert x.repr() == '-18471379832321L'
assert x.hex() == '-0x10ccb4088e01L'
assert x.oct() == '-0414626402107001L'
assert x.format('.!') == (
'-!....!!..!!..!.!!.!......!...!...!!!........!')
assert x.format('abcdefghijkl', '<<', '>>') == '-<<cakdkgdijffjf>>'
def test_tostring(self):
z = rbigint.fromlong(0)
assert z.str() == '0'
assert z.repr() == '0L'
assert z.hex() == '0x0L'
assert z.oct() == '0L'
x = rbigint.fromlong(-18471379832321)
assert x.str() == '-18471379832321'
assert x.repr() == '-18471379832321L'
assert x.hex() == '-0x10ccb4088e01L'
assert x.oct() == '-0414626402107001L'
assert x.format('.!') == (
'-!....!!..!!..!.!!.!......!...!...!!!........!')
assert x.format('abcdefghijkl', '<<', '>>') == '-<<cakdkgdijffjf>>'
def test_args_from_long(self):
BASE = 1 << SHIFT
assert rbigint.fromlong(0).eq(bigint([0], 0))
assert rbigint.fromlong(17).eq(bigint([17], 1))
assert rbigint.fromlong(BASE-1).eq(bigint([intmask(BASE-1)], 1))
assert rbigint.fromlong(BASE).eq(bigint([0, 1], 1))
assert rbigint.fromlong(BASE**2).eq(bigint([0, 0, 1], 1))
assert rbigint.fromlong(-17).eq(bigint([17], -1))
assert rbigint.fromlong(-(BASE-1)).eq(bigint([intmask(BASE-1)], -1))
assert rbigint.fromlong(-BASE).eq(bigint([0, 1], -1))
assert rbigint.fromlong(-(BASE**2)).eq(bigint([0, 0, 1], -1))
def test_args_from_long(self):
BASE = 1 << SHIFT
assert rbigint.fromlong(0).eq(rbigint([0], 0))
assert rbigint.fromlong(17).eq(rbigint([17], 1))
assert rbigint.fromlong(BASE-1).eq(rbigint([BASE-1], 1))
assert rbigint.fromlong(BASE).eq(rbigint([0, 1], 1))
assert rbigint.fromlong(BASE**2).eq(rbigint([0, 0, 1], 1))
assert rbigint.fromlong(-17).eq(rbigint([17], -1))
assert rbigint.fromlong(-(BASE-1)).eq(rbigint([BASE-1], -1))
assert rbigint.fromlong(-BASE).eq(rbigint([0, 1], -1))
assert rbigint.fromlong(-(BASE**2)).eq(rbigint([0, 0, 1], -1))
def test_shift(self):
negative = rbigint.fromlong(-23)
big = rbigint.fromlong(2L ** 100L)
for x in gen_signs([3L ** 30L, 5L ** 20L, 7 ** 300, 0L, 1L]):
f1 = rbigint.fromlong(x)
py.test.raises(ValueError, f1.lshift, negative)
py.test.raises(ValueError, f1.rshift, negative)
py.test.raises(OverflowError, f1.lshift, big)
py.test.raises(OverflowError, f1.rshift, big)
for y in [0L, 1L, 32L, 2304L, 11233L, 3 ** 9]:
f2 = rbigint.fromlong(y)
res1 = f1.lshift(f2).tolong()
res2 = f1.rshift(f2).tolong()
assert res1 == x << y
assert res2 == x >> y
def test_pow_lll(self):
x = 10L
y = 2L
z = 13L
f1 = rbigint.fromlong(x)
f2 = rbigint.fromlong(y)
f3 = rbigint.fromlong(z)
v = f1.pow(f2, f3)
assert v.tolong() == pow(x, y, z)
f1, f2, f3 = [rbigint.fromlong(i)
for i in (10L, -1L, 42L)]
py.test.raises(TypeError, f1.pow, f2, f3)
f1, f2, f3 = [rbigint.fromlong(i)
for i in (10L, 5L, 0L)]
py.test.raises(ValueError, f1.pow, f2, f3)
def test_shift(self):
negative = rbigint.fromlong(-23)
big = rbigint.fromlong(2L**100L)
for x in gen_signs([3L**30L, 5L**20L, 7**300, 0L, 1L]):
f1 = rbigint.fromlong(x)
py.test.raises(ValueError, f1.lshift, negative)
py.test.raises(ValueError, f1.rshift, negative)
py.test.raises(OverflowError, f1.lshift, big)
py.test.raises(OverflowError, f1.rshift, big)
for y in [0L, 1L, 32L, 2304L, 11233L, 3**9]:
f2 = rbigint.fromlong(y)
res1 = f1.lshift(f2).tolong()
res2 = f1.rshift(f2).tolong()
assert res1 == x << y
assert res2 == x >> y
def test__inplace_divrem1(self):
# signs are not handled in the helpers!
for x, y in [(1238585838347L, 3), (1234123412311231L, 1231231), (99, 100)]:
f1 = rbigint.fromlong(x)
f2 = y
remainder = lobj._inplace_divrem1(f1, f1, f2)
assert (f1.tolong(), remainder) == divmod(x, y)
def test_hash(self):
for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
sys.maxint-3, sys.maxint-2, sys.maxint-1, sys.maxint,
] + [randint(0, sys.maxint) for _ in range(100)]:
# hash of machine-sized integers
assert rbigint.fromint(i).hash() == i
# hash of negative machine-sized integers
assert rbigint.fromint(-i-1).hash() == -i-1
#
for i in range(200):
# hash of large integers: should be equal to the hash of the
# integer reduced modulo 2**64-1, to make decimal.py happy
x = randint(0, sys.maxint**5)
y = x % (2**64-1)
assert rbigint.fromlong(x).hash() == rbigint.fromlong(y).hash()
assert rbigint.fromlong(-x).hash() == rbigint.fromlong(-y).hash()
def test_uintmask(self):
assert rbigint.fromint(-1).uintmask() == r_uint(-1)
assert rbigint.fromint(0).uintmask() == r_uint(0)
assert (rbigint.fromint(sys.maxint).uintmask() ==
r_uint(sys.maxint))
assert (rbigint.fromlong(sys.maxint+1).uintmask() ==
r_uint(-sys.maxint-1))
def test_uintmask(self):
assert rbigint.fromint(-1).uintmask() == r_uint(-1)
assert rbigint.fromint(0).uintmask() == r_uint(0)
assert (rbigint.fromint(sys.maxint).uintmask() ==
r_uint(sys.maxint))
assert (rbigint.fromlong(sys.maxint+1).uintmask() ==
r_uint(-sys.maxint-1))
def test_bit_length(self):
assert rbigint.fromlong(0).bit_length() == 0
assert rbigint.fromlong(1).bit_length() == 1
assert rbigint.fromlong(2).bit_length() == 2
assert rbigint.fromlong(3).bit_length() == 2
assert rbigint.fromlong(4).bit_length() == 3
assert rbigint.fromlong(-3).bit_length() == 2
assert rbigint.fromlong(-4).bit_length() == 3
assert rbigint.fromlong(1<<40).bit_length() == 41
def test_tofloat_precision(self):
assert rbigint.fromlong(0).tofloat() == 0.0
for sign in [1, -1]:
for p in xrange(100):
x = long(2**p * (2**53 + 1) + 1) * sign
y = long(2**p * (2**53+ 2)) * sign
rx = rbigint.fromlong(x)
rxf = rx.tofloat()
assert rxf == float(y)
assert rbigint.fromfloat(rxf).tolong() == y
#
x = long(2**p * (2**53 + 1)) * sign
y = long(2**p * 2**53) * sign
rx = rbigint.fromlong(x)
rxf = rx.tofloat()
assert rxf == float(y)
assert rbigint.fromfloat(rxf).tolong() == y
def test__inplace_divrem1(self):
# signs are not handled in the helpers!
x = 1238585838347L
y = 3
f1 = rbigint.fromlong(x)
f2 = y
remainder = lobj._inplace_divrem1(f1, f1, f2)
assert (f1.tolong(), remainder) == divmod(x, y)
def test__divrem1(self):
# signs are not handled in the helpers!
x = 1238585838347L
y = 3
f1 = rbigint.fromlong(x)
f2 = y
div, rem = lobj._divrem1(f1, f2)
assert (div.tolong(), rem) == divmod(x, y)
def test__divrem1(self):
# signs are not handled in the helpers!
x = 1238585838347L
y = 3
f1 = rbigint.fromlong(x)
f2 = y
div, rem = lobj._divrem1(f1, f2)
assert (div.tolong(), rem) == divmod(x, y)
def test__inplace_divrem1(self):
# signs are not handled in the helpers!
x = 1238585838347L
y = 3
f1 = rbigint.fromlong(x)
f2 = y
remainder = lobj._inplace_divrem1(f1, f1, f2)
assert (f1.tolong(), remainder) == divmod(x, y)
def test__muladd1(self):
x = 1238585838347L
y = 3
z = 42
f1 = rbigint.fromlong(x)
f2 = y
f3 = z
prod = lobj._muladd1(f1, f2, f3)
assert prod.tolong() == x * y + z