import collections
import decimal
import math
import operator
import random
import sys
from concurrent.futures import ThreadPoolExecutor

import pytest
from hypothesis import example, given, settings
from hypothesis import strategies as st

import mpmath
from mpmath import (ceil, fadd, fdiv, floor, fmul, fneg, fp, frac, fsub, inf,
                    isinf, isint, isnan, isnormal, iv, monitor, mp, mpc, mpf,
                    mpi, nan, ninf, nint, nint_distance, nstr, pi, rand,
                    workprec)
from mpmath.libmp import (MPZ, finf, fnan, fninf, fnone, fone, from_float,
                          from_int, from_str, mpf_add, mpf_mul, mpf_sub,
                          round_down, round_nearest, round_up, to_float,
                          to_int, to_man_exp)
from mpmath.libmp.backend import MPQ
from mpmath.libmp.libintmath import isprime, jacobi_symbol


def test_type_compare():
    assert mpf(2) == mpc(2,0)
    assert mpf(0) == mpc(0)
    assert mpf(2) != mpc(2, 0.00001)
    assert mpf(2) == 2.0
    assert mpf(2) != 3.0
    assert mpf(2) == 2
    assert mpf(2) != '2.0'
    assert mpc(2) != '2.0'

def test_add():
    assert mpf(2.5) + mpf(3) == 5.5
    assert mpf(2.5) + 3 == 5.5
    assert mpf(2.5) + 3.0 == 5.5
    assert 3 + mpf(2.5) == 5.5
    assert 3.0 + mpf(2.5) == 5.5
    assert (3+0j) + mpf(2.5) == 5.5
    assert mpc(2.5) + mpf(3) == 5.5
    assert mpc(2.5) + 3 == 5.5
    assert mpc(2.5) + 3.0 == 5.5
    assert mpc(2.5) + (3+0j) == 5.5
    assert 3 + mpc(2.5) == 5.5
    assert 3.0 + mpc(2.5) == 5.5
    assert (3+0j) + mpc(2.5) == 5.5

def test_sub():
    assert mpf(2.5) - mpf(3) == -0.5
    assert mpf(2.5) - 3 == -0.5
    assert mpf(2.5) - 3.0 == -0.5
    assert 3 - mpf(2.5) == 0.5
    assert 3.0 - mpf(2.5) == 0.5
    assert (3+0j) - mpf(2.5) == 0.5
    assert mpc(2.5) - mpf(3) == -0.5
    assert mpc(2.5) - 3 == -0.5
    assert mpc(2.5) - 3.0 == -0.5
    assert mpc(2.5) - (3+0j) == -0.5
    assert 3 - mpc(2.5) == 0.5
    assert 3.0 - mpc(2.5) == 0.5
    assert (3+0j) - mpc(2.5) == 0.5

def test_mul():
    assert mpf(2.5) * mpf(3) == 7.5
    assert mpf(2.5) * 3 == 7.5
    assert mpf(2.5) * 3.0 == 7.5
    assert 3 * mpf(2.5) == 7.5
    assert 3.0 * mpf(2.5) == 7.5
    assert (3+0j) * mpf(2.5) == 7.5
    assert mpc(2.5) * mpf(3) == 7.5
    assert mpc(2.5) * 3 == 7.5
    assert mpc(2.5) * 3.0 == 7.5
    assert mpc(2.5) * (3+0j) == 7.5
    assert 3 * mpc(2.5) == 7.5
    assert 3.0 * mpc(2.5) == 7.5
    assert (3+0j) * mpc(2.5) == 7.5

def test_div():
    assert mpf(6) / mpf(3) == 2.0
    assert mpf(6) / 3 == 2.0
    assert mpf(6) / 3.0 == 2.0
    assert 6 / mpf(3) == 2.0
    assert 6.0 / mpf(3) == 2.0
    assert (6+0j) / mpf(3.0) == 2.0
    assert mpc(6) / mpf(3) == 2.0
    assert mpc(6) / 3 == 2.0
    assert mpc(6) / 3.0 == 2.0
    assert mpc(6) / (3+0j) == 2.0
    assert 6 / mpc(3) == 2.0
    assert 6.0 / mpc(3) == 2.0
    assert (6+0j) / mpc(3) == 2.0
    assert 1/mpc(inf, 1) == 0.0
    assert (1+1j)/mpc(2, inf) == 0.0
    assert mpc(inf, 1)**-1 == 0.0

def test_mod():
    assert mpf(3.1) % decimal.Decimal(5.3) == mpf('3.1000000000000001')
    assert mpf(2.53) % inf == mpf(2.53)
    assert mpf(2.53) % ninf == mpf(2.53)

def test_floordiv():
    assert mpf(30.21) // mpf(2.53) == mpf(11)

def test_divmod():
    assert divmod(mpf(30.21), mpf(2.53)) == (mpf(11), mpf(2.380000000000003))

def test_pow():
    assert mpf(6) ** mpf(3) == 216.0
    assert mpf(6) ** 3 == 216.0
    assert mpf(6) ** 3.0 == 216.0
    assert 6 ** mpf(3) == 216.0
    assert 6.0 ** mpf(3) == 216.0
    assert (6+0j) ** mpf(3.0) == 216.0
    assert mpc(6) ** mpf(3) == 216.0
    assert mpc(6) ** 3 == 216.0
    assert mpc(6) ** 3.0 == 216.0
    assert mpc(6) ** (3+0j) == 216.0
    assert 6 ** mpc(3) == 216.0
    assert 6.0 ** mpc(3) == 216.0
    assert (6+0j) ** mpc(3) == 216.0
    assert inf ** mpf(0) == mpf(1)
    assert ninf ** mpf(0) == mpf(1)
    assert nan ** mpf(0) == mpf(1)
    assert mpc(1, -inf)**3 == mpc(-inf, inf)
    assert mpc(1, -inf)**4 == mpc(inf, inf)


def test_mixed_misc():
    assert 1 + mpf(3) == mpf(3) + 1 == 4
    assert 1 - mpf(3) == -(mpf(3) - 1) == -2
    assert 3 * mpf(2) == mpf(2) * 3 == 6
    assert 6 / mpf(2) == mpf(6) / 2 == 3
    assert 1.0 + mpf(3) == mpf(3) + 1.0 == 4
    assert 1.0 - mpf(3) == -(mpf(3) - 1.0) == -2
    assert 3.0 * mpf(2) == mpf(2) * 3.0 == 6
    assert 6.0 / mpf(2) == mpf(6) / 2.0 == 3

def test_add_misc():
    assert mpf(4) + mpf(-70) == -66
    assert mpf(1) + mpf(1.1)/80 == 1 + 1.1/80
    assert mpf((1, 10000000000)) + mpf(3) == mpf((1, 10000000000))
    assert mpf(3) + mpf((1, 10000000000)) == mpf((1, 10000000000))
    assert mpf((1, -10000000000)) + mpf(3) == mpf(3)
    assert mpf(3) + mpf((1, -10000000000)) == mpf(3)
    assert mpf(1) + 1e-15 != 1
    assert mpf(1) + 1e-20 == 1
    assert mpf(1.07e-22) + 0 == mpf(1.07e-22)
    assert mpf(0) + mpf(1.07e-22) == mpf(1.07e-22)

def test_mpf_init():
    a1 = mpf(0.3, prec=20)
    a2 = mpf(0.3, dps=5)
    a3 = mpf(0.3)
    assert a1 == a2
    assert a1 != a3
    assert str(a1) == '0.300000190734863'
    assert str(a3) == '0.3'
    pytest.raises(ValueError, lambda: mpf((1,)))
    pytest.raises(ValueError, lambda: mpf(mpi(1, 2)))
    pytest.raises(TypeError, lambda: mpf(object()))
    pytest.raises(TypeError, lambda: mpf(1 + 1j))
    class SomethingReal:
        def _mpmath_(self, prec, rounding):
            return mp.make_mpf(from_str('1.3', prec, rounding))
    class SomethingComplex:
        def _mpmath_(self, prec, rounding):
            return mp.make_mpc((from_str('1.3', prec, rounding), \
                from_str('1.7', prec, rounding)))
    class mympf:
        @property
        def _mpf_(self):
            return mpf(3.5)._mpf_
    assert mpf(SomethingReal(), prec=20) == mpf('1.3', prec=20)
    pytest.raises(TypeError, lambda: mpf(SomethingComplex()))
    assert mpf(mympf()) == mpf(3.5)
    assert mympf() - mpf(0.5) == mpf(3.0)
    assert mpf(decimal.Decimal('1.5')) == mpf('1.5')
    assert mpf(decimal.Decimal('+inf')) == +inf
    assert mpf(decimal.Decimal('-inf')) == -inf
    assert isnan(mpf(decimal.Decimal('nan')))
    assert mpf(decimal.Decimal(1).exp(), dps=5) == mpf('2.7182807922363281', dps=5)
    assert mpf(decimal.Decimal(1).exp(), prec=0) == mpf('2.718281828459045235360287471', prec=93)
    assert mpf('0x1.4ace478p+33') == mpf(11100000000.0)
    assert mpf('0x1.4ace478p+33', base=0) == mpf(11100000000.0)
    assert mpf('1.4ace478p+33', base=16) == mpf(11100000000.0)
    assert mpf((1, 17813873926281399, -78, 54), prec=5,
               rounding='u') == mpf('-5.9604644775390625e-8')

    assert mpf(float('+inf')) == +inf
    assert mpf(float('-inf')) == -inf
    assert isnan(mpf(float('nan')))

def test_mpc_init():
    class mympc:
        @property
        def _mpc_(self):
            return (mpf(7)._mpf_, mpf(-1)._mpf_)
    assert mpc(3+1j, 7-1j) == mpc(real='4.0', imag='8.0')
    assert mpc(3+1j, mympc()) == mpc(real='4.0', imag='8.0')
    assert mpc('(1+2j)') == mpc(real='1.0', imag='2.0')

def test_mpf_props():
    a = mpf(0.5)
    assert a.man_exp == (1, -1)
    pytest.raises(ValueError, lambda: inf.man_exp)
    pytest.raises(ValueError, lambda: nan.man_exp)
    assert a.man == 1
    assert a.exp == -1
    assert a.bc == 1

def test_mpf_methods():
    assert mpf(0.5).as_integer_ratio() == (1, 2)
    assert mpf('0.3').as_integer_ratio() == (5404319552844595,
                                             18014398509481984)

def test_mpf_magic():
    assert complex(mpf(0.5)) == complex(0.5)

def test_complex_misc():
    # many more tests needed
    assert 1 + mpc(2) == 3
    assert not mpc(2).ae(2 + 1e-13)
    assert mpc(2+1e-15j).ae(2)

def test_complex_zeros():
    for a in [0,2]:
        for b in [0,3]:
            for c in [0,4]:
                for d in [0,5]:
                    assert mpc(a,b)*mpc(c,d) == complex(a,b)*complex(c,d)

def test_hash():
    for i in range(-256, 256):
        assert hash(mpf(i)) == hash(i)
    assert hash(mpf(0.5)) == hash(0.5)
    assert hash(mpc(2,3)) == hash(2+3j)
    # Check that this doesn't fail
    assert hash(inf)
    hash(nan)
    # Check that overflow doesn't assign equal hashes to large numbers
    assert hash(mpf('1e1000')) != hash('1e10000')
    assert hash(mpc(100,'1e1000')) != hash(mpc(200,'1e1000'))
    assert hash(MPQ(1,3))
    assert hash(MPQ(0,1)) == 0
    assert hash(MPQ(-1,1)) == hash(-1)
    assert hash(MPQ(1,1)) == hash(1)
    assert hash(MPQ(5,1)) == hash(5)
    assert hash(MPQ(1,2)) == hash(0.5)
    assert hash(mpf(1)*2**2000) == hash(2**2000)
    assert hash(mpf(1)/2**2000) == hash(MPQ(1,2**2000))

# Advanced rounding test
def test_add_rounding():
    a = from_float(1e-50)
    assert mpf_sub(mpf_add(fone, a, 53, round_up), fone, 53, round_up) == from_float(2.2204460492503131e-16)
    assert mpf_sub(fone, a, 53, round_up) == fone
    assert mpf_sub(fone, mpf_sub(fone, a, 53, round_down), 53, round_down) == from_float(1.1102230246251565e-16)
    assert mpf_add(fone, a, 53, round_down) == fone

def test_almost_equal():
    assert mpf(1.2).ae(mpf(1.20000001), 1e-7)
    assert not mpf(1.2).ae(mpf(1.20000001), 1e-9)
    assert not mpf(-0.7818314824680298).ae(mpf(-0.774695868667929))
    assert inf.ae(inf)
    assert not inf.ae(-inf)
    assert not mpf(1.2).ae(nan)
    assert not mpf(1.2).ae(inf)
    assert not nan.ae(nan)
    assert not nan.ae(inf)

def test_arithmetic_functions():
    ops = [(operator.add, fadd), (operator.sub, fsub), (operator.mul, fmul),
        (operator.truediv, fdiv)]
    a = mpf(0.27)
    b = mpf(1.13)
    c = mpc(0.51+2.16j)
    d = mpc(1.08-0.99j)
    for x in [a,b,c,d]:
        for y in [a,b,c,d]:
            for op, fop in ops:
                if fop is not fdiv:
                    mp.prec = 200
                    z0 = op(x,y)
                mp.prec = 60
                z1 = op(x,y)
                mp.prec = 53
                z2 = op(x,y)
                assert fop(x, y, prec=60) == z1
                assert fop(x, y) == z2
                if fop is not fdiv:
                    assert fop(x, y, prec=inf) == z0
                    assert fop(x, y, dps=inf) == z0
                    assert fop(x, y, exact=True) == z0
                assert fneg(fneg(z1, exact=True), prec=inf) == z1
                assert fneg(z1) == -(+z1)

def test_exact_integer_arithmetic():
    random.seed(0)
    for prec in [6, 10, 25, 40, 100, 250, 725]:
        for rounding in ['d', 'u', 'f', 'c', 'n']:
            mp.dps = prec
            mp.rounding = rounding
            M = 10**(prec-2)
            M2 = 10**(prec//2-2)
            for i in range(10):
                a = random.randint(-M, M)
                b = random.randint(-M, M)
                assert mpf(a, rounding=rounding) == a
                assert int(mpf(a, rounding=rounding)) == a
                assert int(mpf(str(a), rounding=rounding)) == a
                assert mpf(a) + mpf(b) == a + b
                assert mpf(a) - mpf(b) == a - b
                assert -mpf(a) == -a
                a = random.randint(-M2, M2)
                b = random.randint(-M2, M2)
                assert mpf(a) * mpf(b) == a*b
                assert mpf_mul(from_int(a), from_int(b), mp.prec, rounding) == from_int(a*b)

def test_odd_int_bug():
    assert to_int(from_int(3), round_nearest) == 3

def test_str_1000_digits():
    mp.dps = 1001
    # last digit may be wrong
    assert str(mpf(2)**0.5)[-10:-1] == '9518488472'[:9]
    assert str(pi)[-10:-1] == '2164201989'[:9]

def test_str_10000_digits():
    mp.dps = 10001
    # last digit may be wrong
    assert str(mpf(2)**0.5)[-10:-1] == '5873258351'[:9]
    assert str(pi)[-10:-1] == '5256375678'[:9]

def test_monitor():
    f = lambda x: x**2
    a = []
    b = []
    g = monitor(f, a.append, b.append)
    assert g(3) == 9
    assert g(4) == 16
    assert a[0] == ((3,), {})
    assert b[0] == 9

def test_nint_distance():
    assert nint_distance(mpf(-3)) == (-3, -inf)
    assert nint_distance(mpc(-3)) == (-3, -inf)
    assert nint_distance(mpf(-3.1)) == (-3, -3)
    assert nint_distance(mpf(-3.01)) == (-3, -6)
    assert nint_distance(mpf(-3.001)) == (-3, -9)
    assert nint_distance(mpf(-3.0001)) == (-3, -13)
    assert nint_distance(mpf(-2.9)) == (-3, -3)
    assert nint_distance(mpf(-2.99)) == (-3, -6)
    assert nint_distance(mpf(-2.999)) == (-3, -9)
    assert nint_distance(mpf(-2.9999)) == (-3, -13)
    assert nint_distance(mpc(-3+0.1j)) == (-3, -3)
    assert nint_distance(mpc(-3+0.01j)) == (-3, -6)
    assert nint_distance(mpc(-3.1+0.1j)) == (-3, -3)
    assert nint_distance(mpc(-3.01+0.01j)) == (-3, -6)
    assert nint_distance(mpc(-3.001+0.001j)) == (-3, -9)
    assert nint_distance(mpf(0)) == (0, -inf)
    assert nint_distance(mpf(0.01)) == (0, -6)
    assert nint_distance(mpf('1e-100')) == (0, -332)
    pytest.raises(ValueError, lambda: nint_distance(mpc(1, inf)))
    pytest.raises(ValueError, lambda: nint_distance(mpc(inf, 1)))

def test_floor_ceil_nint_frac():
    for n in range(-10,10):
        assert floor(n) == n
        assert floor(n+0.5) == n
        assert ceil(n) == n
        assert ceil(n+0.5) == n+1
        assert nint(n) == n
        # nint rounds to even
        if n % 2 == 1:
            assert nint(n+0.5) == n+1
        else:
            assert nint(n+0.5) == n
    assert floor(inf) == inf
    assert floor(ninf) == ninf
    assert isnan(floor(nan))
    assert ceil(inf) == inf
    assert ceil(ninf) == ninf
    assert isnan(ceil(nan))
    assert nint(inf) == inf
    assert nint(ninf) == ninf
    assert isnan(nint(nan))
    assert floor(0.1) == 0
    assert floor(0.9) == 0
    assert floor(-0.1) == -1
    assert floor(-0.9) == -1
    assert floor(10000000000.1) == 10000000000
    assert floor(10000000000.9) == 10000000000
    assert floor(-10000000000.1) == -10000000000-1
    assert floor(-10000000000.9) == -10000000000-1
    assert floor(1e-100) == 0
    assert floor(-1e-100) == -1
    assert floor(1e100) == 1e100
    assert floor(-1e100) == -1e100
    assert ceil(0.1) == 1
    assert ceil(0.9) == 1
    assert ceil(-0.1) == 0
    assert ceil(-0.9) == 0
    assert ceil(10000000000.1) == 10000000000+1
    assert ceil(10000000000.9) == 10000000000+1
    assert ceil(-10000000000.1) == -10000000000
    assert ceil(-10000000000.9) == -10000000000
    assert ceil(1e-100) == 1
    assert ceil(-1e-100) == 0
    assert ceil(1e100) == 1e100
    assert ceil(-1e100) == -1e100
    assert nint(0.1) == 0
    assert nint(0.9) == 1
    assert nint(-0.1) == 0
    assert nint(-0.9) == -1
    assert nint(10000000000.1) == 10000000000
    assert nint(10000000000.9) == 10000000000+1
    assert nint(-10000000000.1) == -10000000000
    assert nint(-10000000000.9) == -10000000000-1
    assert nint(1e-100) == 0
    assert nint(-1e-100) == 0
    assert nint(1e100) == 1e100
    assert nint(-1e100) == -1e100
    assert floor(3.2+4.6j) == 3+4j
    assert ceil(3.2+4.6j) == 4+5j
    assert nint(3.2+4.6j) == 3+5j
    for n in range(-10,10):
        assert frac(n) == 0
    assert frac(0.25) == 0.25
    assert frac(1.25) == 0.25
    assert frac(2.25) == 0.25
    assert frac(-0.25) == 0.75
    assert frac(-1.25) == 0.75
    assert frac(-2.25) == 0.75
    assert frac('1e100000000000000') == 0
    u = mpf('1e-100000000000000')
    assert frac(u) == u
    assert frac(-u) == 1  # rounding!
    u = mpf('1e-400')
    assert frac(-u, prec=0) == fsub(1, u, exact=True)
    assert frac(3.25+4.75j) == 0.25+0.75j

def test_isnan_etc():
    assert isnan(nan) is True
    assert isnan(3) is False
    assert isnan(mpf(3)) is False
    assert isnan(inf) is False
    assert isnan(mpc(2, nan)) is True
    assert isnan(mpc(2, nan)) is True
    assert isnan(mpc(nan, nan)) is True
    assert isnan(mpc(2, 2)) is False
    assert isnan(mpc(nan, inf)) is True
    assert isnan(mpc(inf, inf)) is False
    assert isnan(MPQ(3, 2)) is False
    assert isnan(MPQ(0, 1)) is False
    assert isinf(inf) is True
    assert isinf(-inf) is True
    assert isinf(3) is False
    assert isinf(nan) is False
    assert isinf(3 + 4j) is False
    assert isinf(mpc(inf)) is True
    assert isinf(mpc(3, inf)) is True
    assert isinf(mpc(inf, 3)) is True
    assert isinf(mpc(inf, inf)) is True
    assert isinf(mpc(nan, inf)) is True
    assert isinf(mpc(inf, nan)) is True
    assert isinf(mpc(nan, nan)) is False
    assert isinf(MPQ(3, 2)) is False
    assert isinf(MPQ(0, 1)) is False
    pytest.raises(TypeError, lambda: isinf(object()))
    assert isnormal(3) is True
    assert isnormal(3.5) is True
    assert isnormal(mpf(3.5)) is True
    assert isnormal(0) is False
    assert isnormal(mpf(0)) is False
    assert isnormal(0.0) is False
    assert isnormal(inf) is False
    assert isnormal(-inf) is False
    assert isnormal(nan) is False
    assert isnormal(float(inf)) is False
    assert isnormal(mpc(0, 0)) is False
    assert isnormal(mpc(3, 0)) is True
    assert isnormal(mpc(0, 3)) is True
    assert isnormal(mpc(3, 3)) is True
    assert isnormal(mpc(0, nan)) is False
    assert isnormal(mpc(0, inf)) is False
    assert isnormal(mpc(3, nan)) is False
    assert isnormal(mpc(3, inf)) is False
    assert isnormal(mpc(3, -inf)) is False
    assert isnormal(mpc(nan, 0)) is False
    assert isnormal(mpc(inf, 0)) is False
    assert isnormal(mpc(nan, 3)) is False
    assert isnormal(mpc(inf, 3)) is False
    assert isnormal(mpc(inf, nan)) is False
    assert isnormal(mpc(nan, inf)) is False
    assert isnormal(mpc(nan, nan)) is False
    assert isnormal(mpc(inf, inf)) is False
    assert isnormal(MPQ(3, 2)) is True
    assert isnormal(MPQ(0, 1)) is False
    pytest.raises(TypeError, lambda: isnormal(object()))
    assert isnormal(math.nextafter(0, 1)) is True  # issue 946
    assert fp.isnormal(math.nextafter(0, 1)) is False
    assert fp.isnormal(0.0) is False
    assert fp.isnormal(-0.0) is False
    assert fp.isnormal(fp.nan) is False
    assert fp.isnormal(fp.inf) is False
    assert fp.isnormal(fp.ninf) is False
    assert fp.isnormal(1.0) is True
    assert fp.isnormal(sys.float_info.min) is True
    assert fp.isnormal(1+0j) is True
    assert fp.isnormal(0j) is False
    assert fp.isnormal(-0j) is False
    assert fp.isnormal(1+1j) is True
    assert fp.isnormal(complex('inf+1j')) is False
    assert isint(3) is True
    assert isint(0) is True
    assert isint(int(3)) is True
    assert isint(int(0)) is True
    assert isint(mpf(3)) is True
    assert isint(mpf(0)) is True
    assert isint(mpf(-3)) is True
    assert isint(mpf(3.2)) is False
    assert isint(3.2) is False
    assert isint(nan) is False
    assert isint(inf) is False
    assert isint(-inf) is False
    assert isint(mpc(0)) is True
    assert isint(mpc(3)) is True
    assert isint(mpc(3.2)) is False
    assert isint(mpc(3, inf)) is False
    assert isint(mpc(inf)) is False
    assert isint(mpc(3, 2)) is False
    assert isint(mpc(0, 2)) is False
    assert isint(mpc(3, 2), gaussian=True) is True
    assert isint(mpc(3, 0), gaussian=True) is True
    assert isint(mpc(0, 3), gaussian=True) is True
    assert isint(3 + 4j) is False
    assert isint(3 + 4j, gaussian=True) is True
    assert isint(3 + 0j) is True
    assert isint(MPQ(3, 2)) is False
    assert isint(MPQ(3, 9)) is False
    assert isint(MPQ(9, 3)) is True
    assert isint(MPQ(0, 4)) is True
    assert isint(MPQ(1, 1)) is True
    assert isint(MPQ(-1, 1)) is True
    pytest.raises(TypeError, lambda: isint(object()))
    assert mp.isnpint(0) is True
    assert mp.isnpint(1) is False
    assert mp.isnpint(-1) is True
    assert mp.isnpint(-1.1) is False
    assert mp.isnpint(-1.0) is True
    assert mp.isnpint(MPQ(1, 2)) is False
    assert mp.isnpint(MPQ(-1, 2)) is False
    assert mp.isnpint(MPQ(-3, 1)) is True
    assert mp.isnpint(MPQ(0, 1)) is True
    assert mp.isnpint(MPQ(1, 1)) is False
    assert mp.isnpint(0 + 0j) is True
    assert mp.isnpint(-1 + 0j) is True
    assert mp.isnpint(-1.1 + 0j) is False
    assert mp.isnpint(-1 + 0.1j) is False
    assert mp.isnpint(0 + 0.1j) is False
    assert mp.isnpint(inf) is False


def test_isprime():
    assert isprime(MPZ(2))
    assert not isprime(MPZ(4))


def test_issue_438():
    assert mpf(finf) == mpf('inf')
    assert mpf(fninf) == mpf('-inf')
    assert mpf(fnan)._mpf_ == mpf('nan')._mpf_


def test_ctx_mag():
    assert mp.mag(MPQ(1, 2)) == 0
    assert mp.mag(MPQ(2)) == 2
    assert mp.mag(MPQ(0)) == mpf('-inf')

def test_to_man_exp():
    assert to_man_exp(fnone, signed=False) == (1, 0)

def test_rand_precision():
    """
    Test precision of rand()
    """
    def get_remainder(x, bits):
        """
        Return ``(x % 2**-bits) * (2**bits)``.
        If this is nonzero, we know for sure that x was generated with a resolution greater than ``bits``.
        """
        x = x * 2 ** bits
        return x - int(x)
    # Python float (to test the tests)
    random.seed(42)
    x = random.random()
    assert x == 0.6394267984578837, "failed to initialize random() reproducibly"
    assert get_remainder(x, 53) == 0
    assert get_remainder(x, 52) != 0 # Note: this is only true for specific random seeds!
    # fp:
    random.seed(42)
    x = fp.rand()
    assert get_remainder(x, 53) == 0
    assert get_remainder(x, 52) != 0 # Note: this is only true for specific random seeds!
    # mp:
    with workprec(123):
        random.seed(43)
        x = mp.rand()
        assert get_remainder(x, 123) == 0
        assert get_remainder(x, 122) != 0  # Note: this is only true for specific random seeds!
    # iv:
    oldprec = iv.prec # REMOVE ME LATER - workaround for the bug that workprec doesn't work for iv
    iv.prec=123 # REMOVE ME LATER - workaround for the bug that workprec doesn't work for iv
    with workprec(123):
        random.seed(43)
        x = iv.rand()
        assert get_remainder(x, 123) == 0
        assert get_remainder(x, 122) != 0  # Note: this is only true for specific random seeds!
    iv.prec = oldprec # REMOVE ME LATER - workaround for the bug that workprec  doesn't work for iv

def test_issue_260():
    assert mpc(str(mpc(1j))) == mpc(1j)


@settings(max_examples=10000)
@given(st.floats(allow_nan=True,
                 allow_infinity=True,
                 allow_subnormal=True),
       st.integers(min_value=0, max_value=15))
@example(0.5, 0)
@example(-0.5, 0)
@example(1.5, 0)
@example(-1.5, 0)
@example(2.675, 2)
@example(math.inf, 3)
@example(-math.inf, 1)
@example(8.9884656743115795e+307, 0)
def test_round_bulk(x, n):
    mp.prec = fp.prec
    m = mpf(x)
    mr = round(m, n)
    xr = round(x, n)
    if isnan(x):
        assert isnan(mr)
        assert isnan(xr)
    else:
        assert float(mr) == xr
        # mp context doesn't support negative zero
        if not xr and math.copysign(1., xr) == -1.:
            return
        assert nstr(mr, n=14, base=16, strip_zeros=False,
                    show_zero_exponent=True, binary_exp=True) == xr.hex()
    try:
        xr = round(x)
    except ValueError:
        pytest.raises(ValueError, lambda: round(m))
    except OverflowError:
        pytest.raises(OverflowError, lambda: round(m))
    else:
        mr = round(m)
        assert type(mr) is int
        assert mr == xr


def test_rounding_prop():
    assert mp.rounding == 'n'
    assert mp.sin(1) == mpf('0x1.aed548f090ceep-1')
    mp.rounding = 'u'
    assert mp.rounding == 'u'
    assert mp.sin(1) == mpf('0x1.aed548f090cefp-1')
    with pytest.raises(ValueError):
        mp.rounding = 'x'


def test_from_man_exp():
    with pytest.raises(TypeError):
        mp.mpf(("!", 1))


def test_issue_985():
    assert hash(mpc(-1)) == -2
    assert hash(mpmath.mpc(-1000004, 1)) == -2
    assert mpc(-1) in {1, -1}


def test_issue_975():
    def worker():
        mp = mpmath.MPContext()
        mp.quad(lambda x: mp.exp(-x**2), [-mp.inf, mp.inf]) ** 2
    sz = 100
    tpe = ThreadPoolExecutor(max_workers=4)
    futures = [None]*sz
    for i in range(sz):
        futures[i] = tpe.submit(worker)
    assert len(collections.Counter(f.result() for f in futures))


def test_to_float():
    # coverage tests
    mp.dps = 1000

    x = mpf('0b1.1111111111111111111111111111111111111'
            '11111111111111011p-1023')
    assert float(x).hex() == '0x0.fffffffffffffp-1022'
    x = mpf('0b1.1111111111111111111111111111111111111'
            '11111111111111111p-1023')
    assert float(x).hex() == '0x1.0000000000000p-1022'

    assert math.isnan(float(mpf('nan')))
    assert float(-mpf('0x1.1p-1075')) == float.fromhex('-0x0.0000000000001p-1022')
    assert float(mpf('0x1.1p-1075')) == float.fromhex('0x0.0000000000001p-1022')

    assert to_float(mpf('0x1p3000')._mpf_) == sys.float_info.max
    assert to_float((-mpf('0x1p3000'))._mpf_) == -sys.float_info.max
    pytest.raises(OverflowError, lambda: to_float(mpf('0x1p3000')._mpf_,
                                                  strict=True,
                                                  rnd=round_nearest))
    pytest.raises(OverflowError, lambda: to_float((-mpf('0x1p3000'))._mpf_,
                                                  strict=True,
                                                  rnd=round_nearest))

def test_issue_1078():
    mp.dps = 5000  # way too large

    # These are adjacent denormals (in 64-bit doubles)
    lo = mpf("0x0.0000000000001p-1022")
    hi = mpf("0x0.0000000000002p-1022")

    # Take a value that's a tiny bit below the
    # midpoint (i.e. closer to `lo`):
    mid = (lo + hi) / 2

    # Offset of 2^-52 ULP: correctly rounds to lo
    val_ok = mid - mpf(2) ** -(1074 + 52)
    # Offset of 2^-53 ULP: was incorrectly rounded to hi (even)
    val_bad = mid - mpf(2) ** -(1074 + 53)

    assert float(val_ok) == float(val_bad) == float(lo)


def test_jacobi_symbol():
    assert jacobi_symbol(25, 41) == 1
    assert jacobi_symbol(-23, 83) == -1
    assert jacobi_symbol(3, 9) == 0
    assert jacobi_symbol(42, 97) == -1
    assert jacobi_symbol(3, 5) == -1
    assert jacobi_symbol(7, 9) == 1
    assert jacobi_symbol(0, 3) == 0
    assert jacobi_symbol(0, 1) == 1
    assert jacobi_symbol(2, 1) == 1
    assert jacobi_symbol(1, 3) == 1
    pytest.raises(ValueError, lambda: jacobi_symbol(3, 8))
    assert jacobi_symbol(10, 3) == 1
    assert jacobi_symbol(10, -3) == 1
    assert jacobi_symbol(-10, 3) == -1
    assert jacobi_symbol(-10, -3) == 1
    assert jacobi_symbol(11, 3) == -1
    assert jacobi_symbol(11, -3) == -1
    assert jacobi_symbol(-11, 3) == 1
    assert jacobi_symbol(-11, -3) == -1


def test_issue_1116():
    mp.prec = 54
    x = mpf('0x1.d55368e2bef2p-4')
    assert repr(x) != "mpf('0.11458149882303958')"
    assert eval(repr(x)) == x


def test_eval_repr_roundtrip():
    for _ in range(10):
        prec = random.randint(10, 1001)
        with workprec(prec):
            for _ in range(1000):
                x = rand()
                assert eval(repr(x)) == x, (prec, x)
                n = random.randint(-100, 300)
                if n > 0:
                    x *= 10**n
                elif x < 0:
                    x /= 10**n
                assert eval(repr(x)) == x, (prec, x)