使用Numba时遇NaN问题：np.tanh复数输入下的异常行为

Great question—this is a classic case of numerical stability differences between Numba's optimized implementations and NumPy's more robust (but sometimes slower) ones. Let's break it down:

NumPy's np.tanh for complex numbers includes numerical safeguards to handle large real parts. When the real component x of z = x + 1j gets very large, tanh(z) mathematically converges to 1 + 0j. NumPy detects this edge case and returns the correct limit directly, avoiding overflow issues.

But Numba's JIT-compiled np.tanh uses a more straightforward (and faster) implementation based on the core formula:

tanh(z) = (e^z - e^{-z}) / (e^z + e^{-z})

When x is large (like 360), e^z explodes to infinity (inf), while e^{-z} shrinks to 0. Calculating (inf - 0)/(inf + 0) gives inf/inf, which Numba evaluates as NaN instead of handling the limit gracefully.

The solution is to implement a numerically stable version of complex tanh that manually handles large real parts before letting Numba compute the standard formula. Here's a working example:

from numba import njit
import numpy as np

@njit
def stable_complex_tanh(z):
    x = z.real
    # Handle large positive real values (tanh converges to 1)
    if x > 20:
        return 1.0 + 0.0j
    # Handle large negative real values (tanh converges to -1)
    elif x < -20:
        return -1.0 + 0.0j
    # Use standard tanh for moderate values where overflow isn't a risk
    else:
        return np.tanh(z)

Why This Works: #

• The threshold of 20 is practical: tanh(20) is already ~0.9999999999999982, which is indistinguishable from 1 for most use cases. You can adjust this threshold based on your precision needs (e.g., 10 would still give extremely accurate results).
• By catching large x values upfront, we avoid the overflow that leads to NaN.

Test It Out: #

# Test with your problematic input
z_large = 360 + 1j
print("NumPy result:", np.tanh(z_large))          # Output: (1+0j)
print("Stable Numba result:", stable_complex_tanh(z_large))  # Output: (1+0j)

For even better performance, you can add explicit type hints to your Numba function to help the JIT compiler optimize further:

@njit('complex128(complex128)')
def stable_complex_tanh(z):
    # Same implementation as above

内容的提问来源于stack exchange，提问作者IacopoTorre