Special case tests need to be updated

[asmeurer]

Right now there are quite a few warnings printed about failing special case parsing:

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for abs not machine-readable: 'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is any value (including ``NaN``), the result is ``+infinity``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for abs not machine-readable: 'If ``a`` is any value (including ``NaN``) and ``b`` is either ``+infinity`` or ``-infinity``, the result is ``+infinity``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for abs not machine-readable: 'If ``a`` is either ``+0`` or ``-0``, the result is equal to ``abs(b)``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for abs not machine-readable: 'If ``b`` is either ``+0`` or ``-0``, the result is equal to ``abs(a)``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for abs not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for abs not machine-readable: 'If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for abs not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``+0``, the result is ``π/2 - 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``NaN``, the result is ``π/2 + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is a finite number and ``b`` is ``+infinity``, the result is ``π/2 - infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is a nonzero finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``π - infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+0 - infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``+infinity``, the result is ``3π/4 - infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``π/4 - infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is ``NaN``, the result is ``NaN ± infinity j`` (sign of the imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+infinity``, the result is ``NaN - infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acos not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``+0``, the result is ``+0 + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is a finite number and ``b`` is ``+infinity``, the result is ``+infinity + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is a nonzero finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``NaN``, the result is ``NaN ± πj/2`` (sign of imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+infinity + πj``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + 3πj/4``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + πj/4``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is ``NaN``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+infinity``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for acosh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1157
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1157: UserWarning: case for add not machine-readable: 'If ``a`` is ``-0`` and ``c`` is ``-0``, the real component of the result is ``-0``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1157
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1157: UserWarning: case for add not machine-readable: 'Similarly, if ``b`` is ``+0`` and ``d`` is ``-0``, the imaginary component of the result is ``+0``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1157
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1157: UserWarning: case for add not machine-readable: '0 + 0j`` and ``z2 = c + dj = -0 - 0j``, the result of ``z1 + z2`` is ``-0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+0``, the result is ``+0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is a positive (i.e., greater than ``0``) finite number and ``b`` is ``+infinity``, the result is ``+infinity + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + πj/4``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+0``, the result is ``NaN + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a nonzero finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+infinity``, the result is ``±infinity + NaN j`` (sign of the real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for asinh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1227
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1227: UserWarning: Special cases found for atan2 but none were parsed
    warn(f"Special cases found for {func_name} but none were parsed")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+0``, the result is ``+0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``NaN``, the result is ``+0 + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``1`` and ``b`` is ``+0``, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is a positive (i.e., greater than ``0``) finite number and ``b`` is ``+infinity``, the result is ``+0 + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is a nonzero finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+0 + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``+0 + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``NaN``, the result is ``+0 + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+infinity``, the result is ``±0 + πj/2`` (sign of the real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for atanh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for copysign not machine-readable: '-|x1_i|'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for copysign not machine-readable: '|x1_i|'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for copysign not machine-readable: 'the sign bit of ``x2_i``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+0``, the result is ``1 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+infinity``, the result is ``NaN + 0j`` (sign of the imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``NaN``, the result is ``NaN + 0j`` (sign of the imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is a nonzero finite number and ``b`` is ``+infinity``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is a nonzero finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+0``, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a nonzero finite number, the result is ``+infinity * cis(b)``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + NaN j`` (sign of the real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``NaN``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is either ``+0`` or ``-0``, the result is ``NaN + 0j`` (sign of the imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a nonzero finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for cosh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for divide not machine-readable: '``a``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for equal not machine-readable: '``x1_i`` equals ``x2_i``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for equal not machine-readable: '``a``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``+0``, the result is ``1 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is a finite number and ``b`` is ``+infinity``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+0``, the result is ``infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is a finite number, the result is ``+0 * cis(b)``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a nonzero finite number, the result is ``+infinity * cis(b)``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``+infinity``, the result is ``0 + 0j`` (signs of real and imaginary components are unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``infinity + NaN j`` (sign of real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``NaN``, the result is ``0 + 0j`` (signs of real and imaginary components are unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``NaN``, the result is ``infinity + NaN j`` (sign of real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+0``, the result is ``NaN + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is not equal to ``0``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for exp not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``+0``, the result is ``0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is a finite number and ``b`` is ``+infinity``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+0``, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is a finite number, the result is ``+0 * cis(b) - 1.0``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a nonzero finite number, the result is ``+infinity * cis(b) - 1.0``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``+infinity``, the result is ``-1 + 0j`` (sign of imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``infinity + NaN j`` (sign of real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``NaN``, the result is ``-1 + 0j`` (sign of imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``NaN``, the result is ``infinity + NaN j`` (sign of real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+0``, the result is ``NaN + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is not equal to ``0``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for expm1 not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1227
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1227: UserWarning: Special cases found for floor_divide but none were parsed
    warn(f"Special cases found for {func_name} but none were parsed")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for hypot not machine-readable: 'any value'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for hypot not machine-readable: 'equivalent to ``abs(x2_i)``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for hypot not machine-readable: 'equivalent to ``abs(x1_i)``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for hypot not machine-readable: 'a finite number or ``NaN``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1157
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1157: UserWarning: case for hypot not machine-readable: 'Underflow may only occur when both arguments are subnormal and the correct result is also subnormal'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1157
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1157: UserWarning: case for hypot not machine-readable: 'x2)``, ``hypot(-x1, x2)``, and ``hypot(-x1, -x2)``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1227
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1227: UserWarning: Special cases found for hypot but none were parsed
    warn(f"Special cases found for {func_name} but none were parsed")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for isfinite not machine-readable: 'If ``a`` is ``NaN`` or ``b`` is ``NaN``, the result is ``False``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for isfinite not machine-readable: 'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is any value, the result is ``False``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for isfinite not machine-readable: 'If ``a`` is any value and ``b`` is either ``+infinity`` or ``-infinity``, the result is ``False``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for isfinite not machine-readable: 'If ``a`` is a finite number and ``b`` is a finite number, the result is ``True``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for isinf not machine-readable: 'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is any value (including ``NaN``), the result is ``True``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for isinf not machine-readable: 'If ``a`` is either a finite number or ``NaN`` and ``b`` is either ``+infinity`` or ``-infinity``, the result is ``True``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for isnan not machine-readable: 'If ``a`` or ``b`` is ``NaN``, the result is ``True``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``-0`` and ``b`` is ``+0``, the result is ``-infinity + πj``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+0``, the result is ``-infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is a finite number and ``b`` is ``+infinity``, the result is ``+infinity + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+infinity + πj``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + 3πj/4``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + πj/4``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is ``NaN``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+infinity``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``-1`` and ``b`` is ``+0``, the result is ``-infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is a finite number and ``b`` is ``+infinity``, the result is ``+infinity + πj/2``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+infinity + πj``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + 3πj/4``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``+infinity + πj/4``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is ``NaN``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+infinity``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for log1p not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1227
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1227: UserWarning: Special cases found for logaddexp but none were parsed
    warn(f"Special cases found for {func_name} but none were parsed")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for multiply not machine-readable: '``a``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for not_equal not machine-readable: '``x1_i`` does not equal ``x2_i``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1154
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1154: UserWarning: case for not_equal not machine-readable: '``a``'
    warn(f"case for {func_name} not machine-readable: '{e.value}'")

array_api_tests/test_special_cases.py:1227
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1227: UserWarning: Special cases found for remainder but none were parsed
    warn(f"Special cases found for {func_name} but none were parsed")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sign not machine-readable: 'If ``a`` is either ``-0`` or ``+0`` and ``b`` is either ``-0`` or ``+0``, the result is ``0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sign not machine-readable: 'If ``a`` is ``NaN`` or ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+0``, the result is ``+0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+infinity``, the result is ``0 + NaN j`` (sign of the real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``NaN``, the result is ``0 + NaN j`` (sign of the real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is a positive (i.e., greater than ``0``) finite number and ``b`` is ``+infinity``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is a positive (i.e., greater than ``0``) finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+0``, the result is ``+infinity + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive finite number, the result is ``+infinity * cis(b)``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``infinity + NaN j`` (sign of the real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``NaN``, the result is ``infinity + NaN j`` (sign of the real component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+0``, the result is ``NaN + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a nonzero finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sinh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:1200
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:1200: UserWarning: Special cases found for square but none were parsed
    warn(f"Special cases found for {func_name} but none were parsed")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``+0``, the result is ``+0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is any value (including ``NaN``) and ``b`` is ``+infinity``, the result is ``+infinity + infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` ``-infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+0 + infinity j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is ``-infinity`` and ``b`` is ``NaN``, the result is ``NaN + infinity j`` (sign of the imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``NaN``, the result is ``+infinity + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is any value, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for sqrt not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+0``, the result is ``+0 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is a nonzero finite number and ``b`` is ``+infinity``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``+infinity``, the result is ``+0 + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is a nonzero finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``+0`` and ``b`` is ``NaN``, the result is ``+0 + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``1 + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``1 + 0j`` (sign of the imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``+infinity`` and ``b`` is ``NaN``, the result is ``1 + 0j`` (sign of the imaginary component is unspecified)'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``+0``, the result is ``NaN + 0j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is a nonzero number, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")

array_api_tests/test_special_cases.py:711
  /Users/aaronmeurer/Documents/array-api-tests/array_api_tests/test_special_cases.py:711: UserWarning: case for tanh not machine-readable: 'If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``'
    warn(f"case for {func_name} not machine-readable: '{case_str}'")