tur/complex

The Complex re + im*i. This is what the `#cx{re im}` literal expands to.

(complex/re (complex/of 3.25 -1.5))  ; => 3.25

x + 0i.

(complex/im (complex/from-float 2.5))  ; => 0

0 + 0i.

(complex/re (complex/zero))  ; => 0

1 + 0i.

(complex/re (complex/one))  ; => 1

0 + 1i.

(complex/im (complex/i))  ; => 1

The real component.

(complex/re (complex/of 3.25 -1.5))  ; => 3.25

The imaginary component.

(complex/im (complex/of 3.25 -1.5))  ; => -1.5

true when the imaginary part is exactly 0.

(complex/real? (complex/from-float 2.5))  ; => true

(a+bi) + (c+di) = (a+c) + (b+d)i.

(complex/re (complex/add (complex/of 3.25 1.5) (complex/of 0.75 0.5)))  ; => 4

(a+bi) - (c+di) = (a-c) + (b-d)i.

(complex/im (complex/sub (complex/of 3.25 1.5) (complex/of 0.75 0.5)))  ; => 1

-(a+bi) = -a - bi.

(complex/re (complex/neg (complex/of 3.25 -1.5)))  ; => -3.25

conj(a+bi) = a - bi.

(complex/im (complex/conj (complex/of 3.25 -1.5)))  ; => 1.5

(a+bi)(c+di) = (ac - bd) + (ad + bc)i, written out as arithmetic rather than deferred to a `__muldc3`-style compiler-runtime helper.

(complex/re (complex/mul (complex/of 3.25 1.5) (complex/of 0.5 2.0)))  ; => -1.375

k*(a+bi) = ka + kb*i.

(complex/re (complex/scale (complex/of 3.25 -1.5) 2.0))  ; => 6.5

x/y. The naive `(ac+bd)/(c^2+d^2)` form overflows whenever `c` or `d` is large enough that its square leaves the double range, even when the true quotient is perfectly ordinary. Smith's algorithm divides through by the larger-magnitude denominator component first, so the intermediates stay near the magnitude of the result: |c| >= |d|: r = d/c, den = c + d*r, x/y = ((a + b*r) + (b - a*r)i)/den |c| < |d|: r = c/d, den = c*r + d, x/y = ((a*r + b) + (b*r - a)i)/den Dividing by the zero complex number yields the IEEE infinity/NaN result float division already produces; it is not an error here.

(complex/re (complex/div (complex/of 3.25 1.5) (complex/of 0.5 0.0)))  ; => 6.5

re^2 + im^2, with no square root. Prefer this to `complex/abs` when only comparing magnitudes -- it is exact where the square root is not.

(complex/abs2 (complex/of 3.0 4.0))  ; => 25

sqrt(re^2 + im^2), computed by scaling out the larger component first (`|a| * sqrt(1 + (b/a)^2)`) so a value whose square would overflow still reports its true magnitude.

(complex/abs (complex/of 3.0 4.0))  ; => 5

atan2(im, re), in (-pi, pi].

(complex/arg (complex/of 0.0 1.5))  ; => 1.5708

e^(a+bi) = e^a * (cos b + i sin b), built from the real libm wrappers in stdlib/math.tur rather than from a complex-valued runtime helper.

(complex/re (complex/exp (complex/of 0.0 0.0)))  ; => 1

true when both the real and the imaginary parts compare equal. This is IEEE float equality, with all the usual caveats.

(complex/eq? (complex/of 3.25 -1.5) (complex/of 3.25 -1.5))  ; => true

A fresh owned String. The sign of the imaginary part is ALWAYS explicit, so the output is unambiguous and never depends on how the imaginary part happens to format.

(complex->string (complex/of 3.25 -1.5))  ; => String "3.25-1.5i"