Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Special case tests need to be updated #284

Open
asmeurer opened this issue Aug 1, 2024 · 2 comments
Open

Special case tests need to be updated #284

asmeurer opened this issue Aug 1, 2024 · 2 comments
Labels
high priority High-priority issue

Comments

@asmeurer
Copy link
Member

asmeurer commented Aug 1, 2024

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}'")
@asmeurer asmeurer mentioned this issue Aug 1, 2024
Merged
@asmeurer asmeurer added the high priority High-priority issue label Nov 14, 2024
@asmeurer asmeurer mentioned this issue Nov 14, 2024
Open
@ev-br
Copy link
Contributor

ev-br commented Nov 16, 2024

Tried looking into it and I've to admit to not understanding what's going on here.
First, where do the cases come from?
Second, dropping a breakpoint,

(Pdb) p case_str
'If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is any value (including ``NaN``), the result is ``+infinity``'
(Pdb) p func_name
'abs'
(Pdb) l
709  	            )
710  	            cases.append(case)
711  	        else:
712  	            if not r_remaining_case.search(case_str):
713  	                breakpoint()
714  ->	                warn(f"case for {func_name} not machine-readable: '{case_str}'")
715  	    return cases
716  	
717  	
718  	class BinaryCond(Protocol):
719  	    def __call__(self, i1: float, i2: float) -> bool:
(Pdb) p r_remaining_case.search(case_str)
None
(Pdb) p r_remaining_case
re.compile('In the remaining cases.+')

so, the failure mode is that parsing completely consumes the case_str. Why is then not having "In the remaining cases" an error?

@asmeurer
Copy link
Member Author

The cases are parsed from the standard itself, which is in the repo as a submodule (and probably needs to be updated). The problem is that the standard was updated with several new cases and the code here that parses them was never updated. (also note that in some cases, the appropriate fix for special cases may be to update the text in the standard to be more consistent)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
high priority High-priority issue
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
2 participants
@asmeurer @ev-br