import math
import cmath

INF = float("inf")
NAN = float("nan")


def float_identical(x, y):
    if math.isnan(x) or math.isnan(y):
        if math.isnan(x) and math.isnan(y):
            return True
    elif x == y:
        if x != 0.0:
            return True
        # both zero; check that signs match
        elif math.copysign(1.0, x) == math.copysign(1.0, y):
            return True
        else:
            return False
    return False


def complex_identical(x, y):
    return float_identical(x.real, y.real) and float_identical(x.imag, y.imag)


###########
# complex #
###########

ZERO_DIVISION = (
    (1 + 1j, 0 + 0j),
    (1 + 1j, 0.0 + 0j),
    (1 + 1j, 0 + 0j),
    (1.0 + 0j, 0 + 0j),
    (1 + 0j, 0 + 0j),
)


def close_abs(x, y, eps=1e-9):
    """Return true iff floats x and y "are close"."""
    # put the one with larger magnitude second
    if abs(x) > abs(y):
        x, y = y, x
    if y == 0:
        return abs(x) < eps
    if x == 0:
        return abs(y) < eps
    # check that relative difference < eps
    return abs((x - y) / y) < eps


def close_complex(x, y, eps=1e-9):
    a = complex(x)
    b = complex(y)
    return close_abs(a.real, b.real, eps) and close_abs(a.imag, b.imag, eps)


def check_div(x, y):
    """Compute complex z=x*y, and check that z/x==y and z/y==x."""
    z = x * y
    if x != 0:
        q = z / x
        if not close_complex(q, y):
            return False
        q = z.__truediv__(x)
        if not close_complex(q, y):
            return False
    if y != 0:
        q = z / y
        if not close_complex(q, x):
            return False
        q = z.__truediv__(y)
        if not close_complex(q, x):
            return False
    return True


@test
def test_truediv():
    from random import random

    simple_real = [float(i) for i in range(-5, 6)]
    simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
    for x in simple_complex:
        for y in simple_complex:
            assert check_div(x, y)

    # A naive complex division algorithm (such as in 2.0) is very prone to
    # nonsense errors for these (overflows and underflows).
    assert check_div(complex(1e200, 1e200), 1 + 0j)
    assert check_div(complex(1e-200, 1e-200), 1 + 0j)

    # Just for fun.
    for i in range(100):
        check_div(complex(random(), random()), complex(random(), random()))

    assert close_complex(complex.__truediv__(2 + 0j, 1 + 1j), 1 - 1j)

    for denom_real, denom_imag in [(0.0, NAN), (NAN, 0.0), (NAN, NAN)]:
        z = complex(0, 0) / complex(denom_real, denom_imag)
        assert math.isnan(z.real)
        assert math.isnan(z.imag)


test_truediv()


@test
def test_richcompare():
    assert not complex.__eq__(1 + 1j, 1 << 10000)
    assert complex.__eq__(1 + 1j, 1 + 1j)
    assert not complex.__eq__(1 + 1j, 2 + 2j)
    assert not complex.__ne__(1 + 1j, 1 + 1j)
    assert complex.__ne__(1 + 1j, 2 + 2j), True
    for i in range(1, 100):
        f = i / 100.0
        assert complex.__eq__(f + 0j, f)
        assert not complex.__ne__(f + 0j, f)
        assert not complex.__eq__(complex(f, f), f)
        assert complex.__ne__(complex(f, f), f)

    import operator

    assert operator.eq(1 + 1j, 1 + 1j) == True
    assert operator.eq(1 + 1j, 2 + 2j) == False
    assert operator.ne(1 + 1j, 1 + 1j) == False
    assert operator.ne(1 + 1j, 2 + 2j) == True


test_richcompare()


@test
def test_pow():
    def pow(a, b):
        return a ** b

    assert close_complex(pow(1 + 1j, 0 + 0j), 1.0)
    assert close_complex(pow(0 + 0j, 2 + 0j), 0.0)
    assert close_complex(pow(1j, -1), 1 / (1j))
    assert close_complex(pow(1j, 200), 1)

    a = 3.33 + 4.43j
    assert a ** (0j) == 1
    assert a ** (0.0 + 0.0j) == 1

    assert (3j) ** (0j) == 1
    assert (3j) ** 0 == 1

    # The following is used to exercise certain code paths
    assert a ** 105 == a ** 105
    assert a ** -105 == a ** -105
    assert a ** -30 == a ** -30

    assert (0.0j) ** 0 == 1


test_pow()


@test
def test_conjugate():
    assert close_complex(complex(5.3, 9.8).conjugate(), 5.3 - 9.8j)


test_conjugate()


@test
def test_cabs():
    nums = [complex(x / 3.0, y / 7.0) for x in range(-9, 9) for y in range(-9, 9)]
    for num in nums:
        assert close_complex((num.real ** 2 + num.imag ** 2) ** 0.5, abs(num))


test_cabs()


@test
def test_negative_zero_repr_str():
    def test(v, expected):
        return str(v) == expected

    assert test(complex(0.0, 1.0), "1j")
    assert test(complex(-0.0, 1.0), "(-0+1j)")
    assert test(complex(0.0, -1.0), "-1j")
    assert test(complex(-0.0, -1.0), "(-0-1j)")

    assert test(complex(0.0, 0.0), "0j")
    assert test(complex(0.0, -0.0), "-0j")
    assert test(complex(-0.0, 0.0), "(-0+0j)")
    assert test(complex(-0.0, -0.0), "(-0-0j)")


test_negative_zero_repr_str()

#########
# cmath #
#########

complex_zeros = [complex(x, y) for x in [0.0, -0.0] for y in [0.0, -0.0]]
complex_infinities = [
    complex(x, y)
    for x, y in [
        (INF, 0.0),  # 1st quadrant
        (INF, 2.3),
        (INF, INF),
        (2.3, INF),
        (0.0, INF),
        (-0.0, INF),  # 2nd quadrant
        (-2.3, INF),
        (-INF, INF),
        (-INF, 2.3),
        (-INF, 0.0),
        (-INF, -0.0),  # 3rd quadrant
        (-INF, -2.3),
        (-INF, -INF),
        (-2.3, -INF),
        (-0.0, -INF),
        (0.0, -INF),  # 4th quadrant
        (2.3, -INF),
        (INF, -INF),
        (INF, -2.3),
        (INF, -0.0),
    ]
]
complex_nans = [
    complex(x, y)
    for x, y in [
        (NAN, -INF),
        (NAN, -2.3),
        (NAN, -0.0),
        (NAN, 0.0),
        (NAN, 2.3),
        (NAN, INF),
        (-INF, NAN),
        (-2.3, NAN),
        (-0.0, NAN),
        (0.0, NAN),
        (2.3, NAN),
        (INF, NAN),
    ]
]


@llvm
@pure
def small() -> float:
    ret double 4.940660e-323


def almost_equal(a, b, rel_err=2e-15, abs_err=small()):
    if math.isnan(a):
        if math.isnan(b):
            return True
        return False

    if math.isinf(a):
        if a == b:
            return True
        return False

    if not a and not b:
        if math.copysign(1.0, a) != math.copysign(1.0, b):
            return False

    absolute_error = abs(b - a)
    if absolute_error <= max(abs_err, rel_err * abs(a)):
        return True
    return False


@test
def test_constants():
    e_expected = 2.71828182845904523536
    pi_expected = 3.14159265358979323846
    assert math.isclose(cmath.pi, pi_expected)
    assert math.isclose(cmath.e, e_expected)


test_constants()


@test
def test_infinity_and_nan_constants():
    assert cmath.inf.real == math.inf
    assert cmath.inf.imag == 0.0
    assert cmath.infj.real == 0.0
    assert cmath.infj.imag == math.inf

    assert math.isnan(cmath.nan.real)
    assert cmath.nan.imag == 0.0
    assert cmath.nanj.real == 0.0
    assert math.isnan(cmath.nanj.imag)

    assert str(cmath.inf) == "inf"
    assert str(cmath.infj) == "infj"
    assert str(cmath.nan) == "nan"
    assert str(cmath.nanj) == "nanj"


test_infinity_and_nan_constants()


@test
def test_user_object():
    class MyComplexOS:
        value: T
        T: type

        def __init__(self, value: T):
            self.value = value

        def __complex__(self):
            return self.value

    x = MyComplexOS(4.2)
    assert cmath.acos(x) == cmath.acos(x.value)
    assert cmath.acosh(x) == cmath.acosh(x.value)
    assert cmath.asin(x) == cmath.asin(x.value)
    assert cmath.asinh(x) == cmath.asinh(x.value)
    assert cmath.atan(x) == cmath.atan(x.value)
    assert cmath.atanh(x) == cmath.atanh(x.value)
    assert cmath.cos(x) == cmath.cos(x.value)
    assert cmath.cosh(x) == cmath.cosh(x.value)
    assert cmath.exp(x) == cmath.exp(x.value)
    assert cmath.log(x) == cmath.log(x.value)
    assert cmath.log10(x) == cmath.log10(x.value)
    assert cmath.sin(x) == cmath.sin(x.value)
    assert cmath.sinh(x) == cmath.sinh(x.value)
    assert cmath.sqrt(x) == cmath.sqrt(x.value)
    assert cmath.tan(x) == cmath.tan(x.value)
    assert cmath.tanh(x) == cmath.tanh(x.value)


test_user_object()


@test
def test_input_type():
    x = 42
    y = float(x)
    assert cmath.acos(x) == cmath.acos(y)
    assert cmath.acosh(x) == cmath.acosh(y)
    assert cmath.asin(x) == cmath.asin(y)
    assert cmath.asinh(x) == cmath.asinh(y)
    assert cmath.atan(x) == cmath.atan(y)
    assert cmath.atanh(x) == cmath.atanh(y)
    assert cmath.cos(x) == cmath.cos(y)
    assert cmath.cosh(x) == cmath.cosh(y)
    assert cmath.exp(x) == cmath.exp(y)
    assert cmath.log(x) == cmath.log(y)
    assert cmath.log10(x) == cmath.log10(y)
    assert cmath.sin(x) == cmath.sin(y)
    assert cmath.sinh(x) == cmath.sinh(y)
    assert cmath.sqrt(x) == cmath.sqrt(y)
    assert cmath.tan(x) == cmath.tan(y)
    assert cmath.tanh(x) == cmath.tanh(y)


test_input_type()


@test
def test_cmath_matches_math():
    test_values = [0.01, 0.1, 0.2, 0.5, 0.9, 0.99]
    unit_interval = test_values + [-x for x in test_values] + [0.0, 1.0, -1.0]
    positive = test_values + [1.0] + [1.0 / x for x in test_values]
    nonnegative = [0.0] + positive
    real_line = [0.0] + positive + [-x for x in positive]

    test_functions = {
        "acos": unit_interval,
        "asin": unit_interval,
        "atan": real_line,
        "cos": real_line,
        "cosh": real_line,
        "exp": real_line,
        "log": positive,
        "log10": positive,
        "sin": real_line,
        "sinh": real_line,
        "sqrt": nonnegative,
        "tan": real_line,
        "tanh": real_line,
    }

    for v in test_functions["acos"]:
        z = cmath.acos(v)
        assert almost_equal(z.real, math.acos(v))
        assert z.imag == 0.0

    for v in test_functions["asin"]:
        z = cmath.asin(v)
        assert almost_equal(z.real, math.asin(v))
        assert z.imag == 0.0

    for v in test_functions["atan"]:
        z = cmath.atan(v)
        assert almost_equal(z.real, math.atan(v))
        assert z.imag == 0.0

    for v in test_functions["cos"]:
        z = cmath.cos(v)
        assert almost_equal(z.real, math.cos(v))
        assert z.imag == 0.0

    for v in test_functions["cosh"]:
        z = cmath.cosh(v)
        assert almost_equal(z.real, math.cosh(v))
        assert z.imag == 0.0

    for v in test_functions["exp"]:
        z = cmath.exp(v)
        assert almost_equal(z.real, math.exp(v))
        assert z.imag == 0.0

    for v in test_functions["log"]:
        z = cmath.log(v)
        assert almost_equal(z.real, math.log(v))
        assert z.imag == 0.0

    for v in test_functions["log10"]:
        z = cmath.log10(v)
        assert almost_equal(z.real, math.log10(v))
        assert z.imag == 0.0

    for v in test_functions["sin"]:
        z = cmath.sin(v)
        assert almost_equal(z.real, math.sin(v))
        assert z.imag == 0.0

    for v in test_functions["sinh"]:
        z = cmath.sinh(v)
        assert almost_equal(z.real, math.sinh(v))
        assert z.imag == 0.0

    for v in test_functions["sqrt"]:
        z = cmath.sqrt(v)
        assert almost_equal(z.real, math.sqrt(v))
        assert z.imag == 0.0

    for v in test_functions["tan"]:
        z = cmath.tan(v)
        assert almost_equal(z.real, math.tan(v))
        assert z.imag == 0.0

    for v in test_functions["tanh"]:
        z = cmath.tanh(v)
        assert almost_equal(z.real, math.tanh(v))
        assert z.imag == 0.0

    for base in [0.5, 2.0, 10.0]:
        for v in positive:
            z = cmath.log(v, base)
            s = math.log(v, base)
            # added 'or z.real == s' since Codon version gives -0 vs. +0 in one test
            assert almost_equal(z.real, math.log(v, base)) or z.real == s
            assert z.imag == 0.0


test_cmath_matches_math()


@test
def test_polar():
    def check(arg, expected):
        got = cmath.polar(arg)
        return all(almost_equal(e, g) for e, g in zip(expected, got))

    pi = cmath.pi
    assert check(0, (0.0, 0.0))
    assert check(1, (1.0, 0.0))
    assert check(-1, (1.0, pi))
    assert check(1j, (1.0, pi / 2))
    assert check(-3j, (3.0, -pi / 2))
    inf = float("inf")
    assert check(complex(inf, 0), (inf, 0.0))
    assert check(complex(-inf, 0), (inf, pi))
    assert check(complex(3, inf), (inf, pi / 2))
    assert check(complex(5, -inf), (inf, -pi / 2))
    assert check(complex(inf, inf), (inf, pi / 4))
    assert check(complex(inf, -inf), (inf, -pi / 4))
    assert check(complex(-inf, inf), (inf, 3 * pi / 4))
    assert check(complex(-inf, -inf), (inf, -3 * pi / 4))
    nan = float("nan")
    assert check(complex(nan, 0), (nan, nan))
    assert check(complex(0, nan), (nan, nan))
    assert check(complex(nan, nan), (nan, nan))
    assert check(complex(inf, nan), (inf, nan))
    assert check(complex(-inf, nan), (inf, nan))
    assert check(complex(nan, inf), (inf, nan))
    assert check(complex(nan, -inf), (inf, nan))


test_polar()


@test
def test_phase():
    from cmath import phase, pi

    assert almost_equal(phase(0), 0.0)
    assert almost_equal(phase(1.0), 0.0)
    assert almost_equal(phase(-1.0), pi)
    assert almost_equal(phase(-1.0 + 1e-300j), pi)
    assert almost_equal(phase(-1.0 - 1e-300j), -pi)
    assert almost_equal(phase(1j), pi / 2)
    assert almost_equal(phase(-1j), -pi / 2)

    # zeros
    assert phase(complex(0.0, 0.0)) == 0.0
    assert phase(complex(0.0, -0.0)) == -0.0
    assert phase(complex(-0.0, 0.0)) == pi
    assert phase(complex(-0.0, -0.0)) == -pi

    # infinities
    assert almost_equal(phase(complex(-INF, -0.0)), -pi)
    assert almost_equal(phase(complex(-INF, -2.3)), -pi)
    assert almost_equal(phase(complex(-INF, -INF)), -0.75 * pi)
    assert almost_equal(phase(complex(-2.3, -INF)), -pi / 2)
    assert almost_equal(phase(complex(-0.0, -INF)), -pi / 2)
    assert almost_equal(phase(complex(0.0, -INF)), -pi / 2)
    assert almost_equal(phase(complex(2.3, -INF)), -pi / 2)
    assert almost_equal(phase(complex(INF, -INF)), -pi / 4)
    assert phase(complex(INF, -2.3)) == -0.0
    assert phase(complex(INF, -0.0)) == -0.0
    assert phase(complex(INF, 0.0)) == 0.0
    assert phase(complex(INF, 2.3)) == 0.0
    assert almost_equal(phase(complex(INF, INF)), pi / 4)
    assert almost_equal(phase(complex(2.3, INF)), pi / 2)
    assert almost_equal(phase(complex(0.0, INF)), pi / 2)
    assert almost_equal(phase(complex(-0.0, INF)), pi / 2)
    assert almost_equal(phase(complex(-2.3, INF)), pi / 2)
    assert almost_equal(phase(complex(-INF, INF)), 0.75 * pi)
    assert almost_equal(phase(complex(-INF, 2.3)), pi)
    assert almost_equal(phase(complex(-INF, 0.0)), pi)

    # real or imaginary part NaN
    for z in complex_nans:
        assert math.isnan(phase(z))


test_phase()


@test
def test_abs():
    # zeros
    for z in complex_zeros:
        assert abs(z) == 0.0

    # infinities
    for z in complex_infinities:
        assert abs(z) == INF

    # real or imaginary part NaN
    assert abs(complex(NAN, -INF)) == INF
    assert math.isnan(abs(complex(NAN, -2.3)))
    assert math.isnan(abs(complex(NAN, -0.0)))
    assert math.isnan(abs(complex(NAN, 0.0)))
    assert math.isnan(abs(complex(NAN, 2.3)))
    assert abs(complex(NAN, INF)) == INF
    assert abs(complex(-INF, NAN)) == INF
    assert math.isnan(abs(complex(-2.3, NAN)))
    assert math.isnan(abs(complex(-0.0, NAN)))
    assert math.isnan(abs(complex(0.0, NAN)))
    assert math.isnan(abs(complex(2.3, NAN)))
    assert abs(complex(INF, NAN)) == INF
    assert math.isnan(abs(complex(NAN, NAN)))


test_abs()


def c_equal(a, b):
    eps = 1e-7
    if abs(a.real - b[0]) > eps or abs(a.imag - b[1]) > eps:
        return False
    return True


@test
def test_rect():
    from cmath import rect, pi

    assert c_equal(rect(0, 0), (0, 0))
    assert c_equal(rect(1, 0), (1.0, 0))
    assert c_equal(rect(1, -pi), (-1.0, 0))
    assert c_equal(rect(1, pi / 2), (0, 1.0))
    assert c_equal(rect(1, -pi / 2), (0, -1.0))


test_rect()


@test
def test_isfinite():
    real_vals = [float("-inf"), -2.3, -0.0, 0.0, 2.3, float("inf"), float("nan")]
    for x in real_vals:
        for y in real_vals:
            z = complex(x, y)
            assert cmath.isfinite(z) == (math.isfinite(x) and math.isfinite(y))


test_isfinite()


@test
def test_isnan():
    assert not cmath.isnan(1)
    assert not cmath.isnan(1j)
    assert not cmath.isnan(INF)
    assert cmath.isnan(NAN)
    assert cmath.isnan(complex(NAN, 0))
    assert cmath.isnan(complex(0, NAN))
    assert cmath.isnan(complex(NAN, NAN))
    assert cmath.isnan(complex(NAN, INF))
    assert cmath.isnan(complex(INF, NAN))


test_isnan()


@test
def test_isinf():
    assert not cmath.isinf(1)
    assert not cmath.isinf(1j)
    assert not cmath.isinf(NAN)
    assert cmath.isinf(INF)
    assert cmath.isinf(complex(INF, 0))
    assert cmath.isinf(complex(0, INF))
    assert cmath.isinf(complex(INF, INF))
    assert cmath.isinf(complex(NAN, INF))
    assert cmath.isinf(complex(INF, NAN))


test_isinf()


@test
def test_tanh_sign():
    for z in complex_zeros:
        assert complex_identical(cmath.tanh(z), z)


test_tanh_sign()


@test
def test_atan_sign():
    for z in complex_zeros:
        assert complex_identical(cmath.atan(z), z)


test_atan_sign()


@test
def test_atanh_sign():
    for z in complex_zeros:
        assert complex_identical(cmath.atanh(z), z)


test_atanh_sign()


@test
def test_is_close():
    # test complex values that are close to within 12 decimal places
    complex_examples = [
        (1.0 + 1.0j, 1.000000000001 + 1.0j),
        (1.0 + 1.0j, 1.0 + 1.000000000001j),
        (-1.0 + 1.0j, -1.000000000001 + 1.0j),
        (1.0 - 1.0j, 1.0 - 0.999999999999j),
    ]

    for a, b in complex_examples:
        assert cmath.isclose(a, b, rel_tol=1e-12)
        assert not cmath.isclose(a, b, rel_tol=1e-13)

    # test values near zero that are near to within three decimal places
    near_zero_examples = [
        (0.001j, 0),
        (0.001 + 0j, 0),
        (0.001 + 0.001j, 0),
        (-0.001 + 0.001j, 0),
        (0.001 - 0.001j, 0),
        (-0.001 - 0.001j, 0),
    ]

    for a, b in near_zero_examples:
        assert cmath.isclose(a, b, abs_tol=1.5e-03)
        assert not cmath.isclose(a, b, abs_tol=0.5e-03)

    assert cmath.isclose(0.001 - 0.001j, 0.001 + 0.001j, abs_tol=2e-03)
    assert not cmath.isclose(0.001 - 0.001j, 0.001 + 0.001j, abs_tol=1e-03)


test_is_close()


@test
def test_cmath_testcases():
    def check(exp, got, flags):
        def close(a, b):
            if math.isnan(a):
                return math.isnan(b)
            elif math.isnan(b):
                return math.isnan(a)
            return math.isclose(a, b, rel_tol=1e-10, abs_tol=1e-15)

        x1 = exp.real
        y1 = exp.imag

        x2 = got.real
        y2 = got.imag

        if "ignore-real-sign" in flags:
            x1 = math.fabs(x1)
            x2 = math.fabs(x2)

        if "ignore-imag-sign" in flags:
            y1 = math.fabs(y1)
            y2 = math.fabs(y2)

        return close(x1, x2) and close(y1, y2)

    def run_test(test):
        v = test.split()
        if not v:
            return True
        name = v[0]
        func = v[1]
        inp = complex(float(v[2]), float(v[3]))
        exp = complex(float(v[5]), float(v[6]))
        flags = v[7:]

        got = complex()
        if func == "rect":
            got = cmath.rect(inp.real, inp.imag)
        elif func == "polar":
            got = complex(*cmath.polar(inp))
        elif func == "exp":
            got = cmath.exp(inp)
        elif func == "log":
            got = cmath.log(inp)
        elif func == "log10":
            got = cmath.log10(inp)
        elif func == "sqrt":
            got = cmath.sqrt(inp)
        elif func == "acos":
            got = cmath.acos(inp)
        elif func == "asin":
            got = cmath.asin(inp)
        elif func == "atan":
            got = cmath.atan(inp)
        elif func == "cos":
            got = cmath.cos(inp)
        elif func == "sin":
            got = cmath.sin(inp)
        elif func == "tan":
            got = cmath.tan(inp)
        elif func == "acosh":
            got = cmath.acosh(inp)
        elif func == "asinh":
            got = cmath.asinh(inp)
        elif func == "atanh":
            got = cmath.atanh(inp)
        elif func == "cosh":
            got = cmath.cosh(inp)
        elif func == "sinh":
            got = cmath.sinh(inp)
        elif func == "tanh":
            got = cmath.tanh(inp)
        else:
            assert False, f"ERROR: unknown function: {func}"

        if not check(exp, got, flags):
            print(f"{name} {func} {inp=} {got=} {exp=} {flags=}")
            return False
        return True

    tests = []
    with open("test/stdlib/cmath_testcases.txt") as f:
        for line in f:
            line = line.strip()
            if not line.startswith("--"):
                tests.append(line)

    for test in tests:
        assert run_test(test)


test_cmath_testcases()


@test
def test_complex64():
    c64 = complex64
    z = c64(.5 + .5j)
    assert c64() == z * 0
    assert z + 1 == c64(1.5, .5)
    assert bool(z) == True
    assert bool(0 * z) == False
    assert +z == z
    assert -z == c64(-.5 - .5j)
    assert abs(z) == float32(0.7071067811865476)
    assert z + 1 == c64(1.5 + .5j)
    assert 1j + z == c64(.5 + 1.5j)
    assert z * 2 == c64(1 + 1j)
    assert 2j * z == c64(-1 + 1j)
    assert z / .5 == c64(1 + 1j)
    assert 1j / z == c64(1 + 1j)
    assert z ** 2 == c64(.5j)
    y = 1j ** z
    assert math.isclose(float(y.real), 0.32239694194483454)
    assert math.isclose(float(y.imag), 0.32239694194483454)
    assert z != -z
    assert z != 0
    assert z.real == float32(.5)
    assert (z + 1j).imag == float32(1.5)
    assert z.conjugate() == c64(.5 - .5j)
    assert z.__copy__() == z
    assert hash(z)
    assert c64(complex(z)) == z

test_complex64()
