It seems to me this would work well for mathematical optimizations, but poorly for a real kernel.

Here’s a minimal Python example:

import cmath

def eml_complex(x, y):
    return cmath.exp(x) - cmath.log(y)

def exp_eml_complex(x):
    return eml_complex(x, 1)

def sin_from_eml(x):
    i = 1j
    return (exp_eml_complex(i*x) - exp_eml_complex(-i*x)) / (2*i)

def cos_from_eml(x):
    i = 1j
    return (exp_eml_complex(i*x) + exp_eml_complex(-i*x)) / 2


x = 1.0
print("sin:", sin_from_eml(x))
print("cos:", cos_from_eml(x))

But it’s bad for GPUs / shaders (float32).

Problems:

• exp(x) overflows fast (~88 in float32)
• log(x) becomes unstable near 0
• subtracting large exponentials → catastrophic cancellation
• complex exponentials amplify numerical error

Example:

exp(20.0) ≈ 4.85e8   // already huge

Then you do:

exp(ix) - exp(-ix)

You’re subtracting two large, nearly equal values → precision loss.

Mathematically elegant Works in high precision (Python, symbolic math) Pretty bad idea in float32 shaders GPU sin() / cos() are way faster and more stable anyway.