Add π parsing support for complex values

- Added r_complex_value regex pattern to capture complex numbers with π expressions
- Added parse_complex_value() function to parse complex value strings
- Regex correctly handles expressions like "+0 + πj/2" by capturing denominator after 'j'
- Supports formats: "πj/2", "π/2j", "NaN + NaN j", etc.
- All test cases pass including the critical "+0 + πj/2" case

Co-authored-by: ev-br <2133832+ev-br@users.noreply.github.com>

Author: Copilot

array_api_tests/test_special_cases.py

@@ -128,6 +128,9 @@ def abs_cond(i: float) -> bool:
 }
 r_value = re.compile(r"([+-]?)(.+)")
 r_pi = re.compile(r"(\d?)π(?:/(\d))?")
+r_complex_value = re.compile(
+    r"([+-]?)([^\s]+)\s*([+-])\s*([^\s]+)\s*j\s*(?:/(\d+))?"
+)
 
 
 @dataclass
@@ -167,6 +170,38 @@ def parse_value(value_str: str) -> float:
     return value
 
 
+def parse_complex_value(value_str: str) -> complex:
+    """
+    Parses a complex value string to return a complex number, e.g.
+
+        >>> parse_complex_value('+0 + 0j')
+        0j
+        >>> parse_complex_value('+0 + πj/2')
+        1.5707963267948966j
+        >>> parse_complex_value('NaN + NaN j')
+        (nan+nanj)
+
+    """
+    m = r_complex_value.match(value_str)
+    if m is None:
+        raise ParseError(value_str)
+    
+    # Parse real part
+    real_sign = m.group(1) or '+'
+    real_value_str = real_sign + m.group(2)
+    real_part = parse_value(real_value_str)
+    
+    # Parse imaginary part
+    imag_sign = m.group(3)
+    imag_value_str = imag_sign + m.group(4)
+    # Check if there's a denominator (group 5)
+    if m.group(5):
+        imag_value_str += '/' + m.group(5)
+    imag_part = parse_value(imag_value_str)
+    
+    return complex(real_part, imag_part)
+
+
 r_code = re.compile(r"``([^\s]+)``")
 r_approx_value = re.compile(
     rf"an implementation-dependent approximation to {r_code.pattern}"

test_pi_parsing.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Simple test to validate π parsing in complex values
+"""
+import sys
+import math
+
+# Add the array_api_tests module to the path
+sys.path.insert(0, '/home/runner/work/array-api-tests/array-api-tests')
+
+from array_api_tests.test_special_cases import parse_complex_value, parse_value
+
+def test_parse_value_pi():
+    """Test that parse_value correctly handles π expressions"""
+    # Test simple π
+    result = parse_value('π')
+    assert abs(result - math.pi) < 1e-10, f"Expected {math.pi}, got {result}"
+    print("✓ parse_value('π') works")
+    
+    # Test π/2
+    result = parse_value('π/2')
+    expected = math.pi / 2
+    assert abs(result - expected) < 1e-10, f"Expected {expected}, got {result}"
+    print(f"✓ parse_value('π/2') = {result}")
+    
+    # Test 3π/4
+    result = parse_value('3π/4')
+    expected = 3 * math.pi / 4
+    assert abs(result - expected) < 1e-10, f"Expected {expected}, got {result}"
+    print(f"✓ parse_value('3π/4') = {result}")
+
+def test_parse_complex_value():
+    """Test that parse_complex_value correctly handles complex values with π"""
+    # Test +0 + 0j
+    result = parse_complex_value('+0 + 0j')
+    expected = complex(0.0, 0.0)
+    assert result == expected, f"Expected {expected}, got {result}"
+    print(f"✓ parse_complex_value('+0 + 0j') = {result}")
+    
+    # Test the critical case: +0 + πj/2
+    result = parse_complex_value('+0 + πj/2')
+    expected = complex(0.0, math.pi / 2)
+    assert abs(result.real - expected.real) < 1e-10, f"Real part mismatch"
+    assert abs(result.imag - expected.imag) < 1e-10, f"Imaginary part mismatch: expected {expected.imag}, got {result.imag}"
+    print(f"✓ parse_complex_value('+0 + πj/2') = {result}")
+    print(f"  Real part: {result.real}")
+    print(f"  Imaginary part: {result.imag} (expected {math.pi/2})")
+    
+    # Test NaN + NaN j
+    result = parse_complex_value('NaN + NaN j')
+    assert math.isnan(result.real), f"Expected NaN for real part, got {result.real}"
+    assert math.isnan(result.imag), f"Expected NaN for imaginary part, got {result.imag}"
+    print(f"✓ parse_complex_value('NaN + NaN j') = {result}")
+    
+    # Test -0 - πj/4
+    result = parse_complex_value('-0 - πj/4')
+    expected = complex(-0.0, -math.pi / 4)
+    assert abs(result.imag - expected.imag) < 1e-10, f"Imaginary part mismatch"
+    print(f"✓ parse_complex_value('-0 - πj/4') = {result}")
+
+if __name__ == '__main__':
+    print("Testing π parsing in complex values...")
+    print()
+    
+    try:
+        test_parse_value_pi()
+        print()
+        test_parse_complex_value()
+        print()
+        print("✅ All tests passed!")
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)