Metrics for math.abs on complex

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze0.0ms (0%)

Memory

0.3MiB live, 0.3MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.9%	0.1%	0%	0%	0%	0
100%	99.9%	0%	0.1%	0%	0%	0%	1

Compiler

Compiled 10 to 5 computations (50% saved)

sample699.0ms (15.7%)

Memory

25.6MiB live, 746.5MiB allocated

Samples

519.0ms

8 256×

valid

Precisions

Click to see histograms. Total time spent on operations: 306.0ms

ival-hypot: 296.0ms (96.7% of total)

ival-true: 6.0ms (2% of total)

ival-assert: 3.0ms (1% of total)

Bogosity

explain200.0ms (4.5%)

Memory

-20.4MiB live, 142.6MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
128	-	3	(-7.141036451366223e-162 -3.1475563204496806e-171)	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`re`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`im`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	111	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	111
↳	`(*.f64 re re)`	overflow	64
↳	`(*.f64 im im)`	overflow	65
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	14	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	14
↳	`(*.f64 re re)`	underflow	59
↳	`(*.f64 im im)`	underflow	58

Confusion

	Predicted +	Predicted -
+	125	3
-	0	128

Precision

1.0

Recall

0.9765625

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	125	0	3
-	0	0	128

Precision?

1.0

Recall?

0.9765625

Freqs

test

number	freq
0	131
1	125

Total Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	1	0	0
-	0	0	0

Precision?

1.0

Recall?

1.0

Samples

35.0ms

512×

valid

Compiler

Compiled 58 to 22 computations (62.1% saved)

Precisions

Click to see histograms. Total time spent on operations: 21.0ms

ival-hypot: 11.0ms (51.5% of total)

ival-mult: 7.0ms (32.7% of total)

ival-add: 2.0ms (9.4% of total)

ival-true: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

preprocess30.0ms (0.7%)

Memory

-10.7MiB live, 26.6MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	16	42
1	35	42
2	77	42
3	145	42
4	204	42
5	217	42
6	219	42
0	6	8
0	10	8
1	11	8
0	11	3

Stop Event

1×	iter limit
1×	saturated
1×	iter limit
1×	saturated

Calls

Call 1

Inputs
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Outputs
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 im re)

Symmetry

(abs im)

(abs re)

(sort re im)

Compiler

Compiled 8 to 6 computations (25% saved)

eval0.0ms (0%)

Memory: 0.6MiB live, 0.6MiB allocated
Compiler: Compiled 0 to 2 computations (-∞% saved)

prune1.0ms (0%)

Memory

1.7MiB live, 1.8MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	54.1%	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Compiler

Compiled 8 to 6 computations (25% saved)

simplify3.0ms (0.1%)

Memory

6.3MiB live, 6.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	-5120	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	0	(*.f64 im im)
cost-diff	0	(*.f64 re re)
cost-diff	128	(+.f64 (.f64 re re) (.f64 im im))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	6	23
0	10	23
1	11	23
0	11	17

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im

Outputs
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 im re)
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 im im (*.f64 re re))
(*.f64 re re)
re
(*.f64 im im)
im

localize38.0ms (0.8%)

Memory

19.3MiB live, 56.8MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(*.f64 re re)
accuracy	0	(*.f64 im im)
accuracy	0.01171875	(+.f64 (.f64 re re) (.f64 im im))
accuracy	29.37596575305573	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

32.0ms

256×

valid

Compiler

Compiled 25 to 8 computations (68% saved)

Precisions

Click to see histograms. Total time spent on operations: 26.0ms

ival-add: 18.0ms (70.5% of total)

ival-hypot: 4.0ms (15.7% of total)

ival-mult: 3.0ms (11.7% of total)

ival-true: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

series9.0ms (0.2%)

Memory

-32.8MiB live, 15.9MiB allocated

Counts

4 → 72

Calls

Call 1

Inputs
#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())
#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())

Outputs
#s(alt (pow im 2) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
4.0ms	im	@	inf	((+ (* re re) (* im im)) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
1.0ms	re	@	0	((+ (* re re) (* im im)) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
1.0ms	re	@	inf	((+ (* re re) (* im im)) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
1.0ms	im	@	0	((+ (* re re) (* im im)) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
1.0ms	re	@	-inf	((+ (* re re) (* im im)) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))

simplify190.0ms (4.3%)

Memory

23.5MiB live, 252.9MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	104	620
1	296	620
2	953	618
3	3667	584
4	6426	582
0	8051	530

Stop Event

1×	iter limit
1×	node limit

Counts

72 → 68

Calls

Call 1

Inputs
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))

Outputs
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))

rewrite255.0ms (5.7%)

Memory

5.5MiB live, 121.3MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	6	21
0	10	21
1	29	21
2	196	21
3	1788	21
0	8624	15

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

4 → 245

Calls

Call 1

Inputs
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
(*.f64 im im)
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval76.0ms (1.7%)

Memory: -5.5MiB live, 68.6MiB allocated
Compiler: Compiled 7 655 to 987 computations (87.1% saved)

prune9.0ms (0.2%)

Memory

30.2MiB live, 30.2MiB allocated

Pruning

7 alts after pruning (7 fresh and 0 done)

	Pruned	Kept	Total
New	306	7	313
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	307	7	314

Accuracy

100.0%

Counts

314 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(hypot.f64 re im)
▶	54.1%	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
▶	4.9%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
▶	53.4%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
	93.2%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
	6.7%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
▶	1.8%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

Compiler

Compiled 82 to 72 computations (12.2% saved)

simplify89.0ms (2%)

Memory

-52.1MiB live, 43.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 12 expressions of interest:

New	Metric	Score
cost-diff	-5120	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
cost-diff	0	(*.f64 re re)
cost-diff	0	(fma.f64 im im (*.f64 re re))
cost-diff	0	(*.f64 re re)
cost-diff	0	#s(approx (+ (* re re) (* im im)) (*.f64 re re))
cost-diff	0	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
cost-diff	0	(*.f64 im im)
cost-diff	0	#s(approx (+ (* re re) (* im im)) (*.f64 im im))
cost-diff	0	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
cost-diff	0	(neg.f64 re)
cost-diff	0	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
cost-diff	0	(hypot.f64 re im)

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	17	86
0	24	78
1	29	78
2	31	78
3	33	78
4	35	78
5	39	78
6	48	78
7	54	78
8	58	78
0	58	78

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(hypot.f64 re im)
re
im
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
im
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
re
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re

Outputs
(hypot.f64 re im)
(hypot.f64 im re)
re
im
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
im
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
re
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 im re)
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re

localize37.0ms (0.8%)

Memory

11.5MiB live, 86.1MiB allocated

Localize:

Found 12 expressions of interest:

New	Metric	Score
accuracy	0	(fma.f64 im im (*.f64 re re))
accuracy	0	(*.f64 re re)
accuracy	29.37596575305573	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0	(*.f64 re re)
accuracy	29.37596575305573	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
accuracy	53.22428081225662	#s(approx (+ (* re re) (* im im)) (*.f64 re re))
accuracy	0	(*.f64 im im)
accuracy	0.46678940715328854	#s(approx (+ (* re re) (* im im)) (*.f64 im im))
accuracy	29.37596575305573	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
accuracy	0	(neg.f64 re)
accuracy	62.832296696240576	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
accuracy	0	(hypot.f64 re im)

Samples

25.0ms

256×

valid

Compiler

Compiled 81 to 11 computations (86.4% saved)

Precisions

Click to see histograms. Total time spent on operations: 15.0ms

ival-hypot: 8.0ms (52.7% of total)

ival-mult: 3.0ms (19.8% of total)

ival-add: 2.0ms (13.2% of total)

ival-neg: 1.0ms (6.6% of total)

ival-true: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

series9.0ms (0.2%)

Memory

29.0MiB live, 29.0MiB allocated

Counts

11 → 228

Calls

Call 1

Inputs
#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())
#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())
#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())
#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())
#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())
#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())
#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())
#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())

Outputs
#s(alt im (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 im im))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 im im)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 re re))) (patch (sqrt.f64 #s(approx (+ ( re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (.f64 re re)) (patch #s(approx (+ ( re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (fma.f64 im im (.f64 re re))) (patch (sqrt.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
1.0ms	re	@	inf	((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (+ (* im im) (* re re)) (sqrt (+ (* im im) (* re re))))
1.0ms	re	@	-inf	((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (+ (* im im) (* re re)) (sqrt (+ (* im im) (* re re))))
1.0ms	im	@	-inf	((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (+ (* im im) (* re re)) (sqrt (+ (* im im) (* re re))))
1.0ms	im	@	inf	((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (+ (* im im) (* re re)) (sqrt (+ (* im im) (* re re))))
0.0ms	re	@	0	((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (+ (* im im) (* re re)) (sqrt (+ (* im im) (* re re))))

simplify245.0ms (5.5%)

Memory

-21.5MiB live, 215.5MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	104	2548
1	296	2548
2	956	2538
3	3681	2368
4	6442	2358
0	8067	2134

Stop Event

1×	iter limit
1×	node limit

Counts

228 → 208

Calls

Call 1

Inputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))

Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))

rewrite176.0ms (4%)

Memory

20.2MiB live, 175.7MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	17	76
0	24	68
1	58	68
2	338	68
3	3368	68
0	8583	68

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

11 → 421

Calls

Call 1

Inputs
(hypot.f64 re im)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
(fma.f64 im im (*.f64 re re))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval146.0ms (3.3%)

Memory: -11.9MiB live, 196.9MiB allocated
Compiler: Compiled 12 517 to 1 138 computations (90.9% saved)

prune26.0ms (0.6%)

Memory

-21.8MiB live, 62.6MiB allocated

Pruning

7 alts after pruning (2 fresh and 5 done)

	Pruned	Kept	Total
New	654	0	654
Fresh	0	2	2
Picked	0	5	5
Done	0	0	0
Total	654	7	661

Accuracy

100.0%

Counts

661 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 re im)
✓	54.1%	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓	4.9%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓	53.4%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
▶	93.2%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
▶	6.7%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
✓	1.8%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

Compiler

Compiled 41 to 36 computations (12.2% saved)

simplify5.0ms (0.1%)

Memory

9.6MiB live, 9.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 8 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(*.f64 re re)
cost-diff	0	(/.f64 #s(literal 1/2 binary64) im)
cost-diff	0	(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
cost-diff	0	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
cost-diff	0	(/.f64 im re)
cost-diff	0	(*.f64 #s(literal 1/2 binary64) im)
cost-diff	0	(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
cost-diff	0	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	68
0	23	68
1	37	68
2	57	68
3	71	68
4	79	68
5	82	68
0	82	58

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(*.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(/.f64 im re)
re
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(*.f64 re re)
re

Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re)
(*.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(/.f64 im re)
re
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(*.f64 re re)
re

localize40.0ms (0.9%)

Memory

23.6MiB live, 95.7MiB allocated

Localize:

Found 8 expressions of interest:

New	Metric	Score
accuracy	0	(/.f64 #s(literal 1/2 binary64) im)
accuracy	0	(*.f64 re re)
accuracy	0.19520630237801292	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
accuracy	4.1978407120854655	(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
accuracy	0	(/.f64 im re)
accuracy	0	(*.f64 #s(literal 1/2 binary64) im)
accuracy	0.12890625	(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
accuracy	59.74066095927664	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))

Samples

31.0ms

256×

valid

Compiler

Compiled 54 to 14 computations (74.1% saved)

Precisions

Click to see histograms. Total time spent on operations: 22.0ms

ival-mult: 10.0ms (45.3% of total)

ival-hypot: 5.0ms (22.6% of total)

ival-add: 4.0ms (18.1% of total)

ival-div: 3.0ms (13.6% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

series22.0ms (0.5%)

Memory

-30.0MiB live, 53.1MiB allocated

Counts

8 → 156

Calls

Call 1

Inputs
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())
#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())
#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())
#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())

Outputs
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor 0 re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re) (taylor 0 re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re) (taylor 0 re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re) (taylor 0 re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt re (taylor -inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1))) (taylor -inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1))) (taylor -inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1))) (taylor -inf re) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor -inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (.f64 #s(literal 1/2 binary64) im) (patch (.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
3.0ms	re	@	inf	((sqrt (+ (* re re) (* im im))) (+ (* (* 1/2 im) (/ im re)) re) (* 1/2 im) (/ im re) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ 1/2 im) (* re re))
3.0ms	im	@	inf	((sqrt (+ (* re re) (* im im))) (+ (* (* 1/2 im) (/ im re)) re) (* 1/2 im) (/ im re) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ 1/2 im) (* re re))
2.0ms	im	@	-inf	((sqrt (+ (* re re) (* im im))) (+ (* (* 1/2 im) (/ im re)) re) (* 1/2 im) (/ im re) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ 1/2 im) (* re re))
2.0ms	re	@	0	((sqrt (+ (* re re) (* im im))) (+ (* (* 1/2 im) (/ im re)) re) (* 1/2 im) (/ im re) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ 1/2 im) (* re re))
2.0ms	im	@	0	((sqrt (+ (* re re) (* im im))) (+ (* (* 1/2 im) (/ im re)) re) (* 1/2 im) (/ im re) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ 1/2 im) (* re re))

simplify192.0ms (4.3%)

Memory

15.9MiB live, 246.3MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	123	1432
1	329	1432
2	1044	1428
3	3928	1300
4	7406	1300
0	8404	1200

Stop Event

1×	iter limit
1×	node limit

Counts

156 → 142

Calls

Call 1

Inputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(* 1/2 (/ (pow im 2) re))
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(/ im re)
(/ im re)
(/ im re)
(/ im re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* 1/2 (/ (pow im 2) re)))
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* 1/2 (/ (pow im 2) re))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* 1/2 (/ (pow im 2) re))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)

Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* 1/2 (/ (pow im 2) re))
(.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64))
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) (.f64 re re)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) (.f64 re re)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) (.f64 re re)) re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) re) re (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(* 1/2 (/ (pow re 2) im))
(.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(neg.f64 (fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64))))
re
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(neg.f64 (fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64))))
(* 1/2 (/ (pow re 2) im))
(.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) im) im (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(* 1/2 (/ (pow re 2) im))
(.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (.f64 re re) #s(literal 1/2 binary64) (.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (.f64 re re) #s(literal 1/2 binary64) (.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (.f64 re re) #s(literal 1/2 binary64) (.f64 im im)) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
(* 1/2 (/ (pow im 2) re))
(.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(neg.f64 (fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(neg.f64 (fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))))
(* 1/2 (/ (pow im 2) re))
(.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(neg.f64 (fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(neg.f64 (fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)

rewrite197.0ms (4.4%)

Memory

-3.5MiB live, 128.4MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	62
0	23	62
1	91	62
2	647	62
0	8182	52

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

8 → 239

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(*.f64 #s(literal 1/2 binary64) im)
(/.f64 im re)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/.f64 #s(literal 1/2 binary64) im)
(*.f64 re re)

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval62.0ms (1.4%)

Memory: 21.7MiB live, 59.5MiB allocated
Compiler: Compiled 8 119 to 942 computations (88.4% saved)

prune179.0ms (4%)

Memory

-12.1MiB live, 24.9MiB allocated

Pruning

6 alts after pruning (1 fresh and 5 done)

	Pruned	Kept	Total
New	380	1	381
Fresh	0	0	0
Picked	2	0	2
Done	0	5	5
Total	382	6	388

Accuracy

100.0%

Counts

388 → 6

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 re im)
✓	54.1%	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓	4.9%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓	53.4%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
▶	99.7%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
✓	1.8%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

Compiler

Compiled 32 to 29 computations (9.4% saved)

simplify4.0ms (0.1%)

Memory

3.0MiB live, 3.0MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(/.f64 re im)
cost-diff	0	(*.f64 (/.f64 re im) re)
cost-diff	0	(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
cost-diff	0	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	11	36
0	15	36
1	22	36
2	35	36
3	41	36
4	44	36
5	47	36
0	47	31

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(*.f64 (/.f64 re im) re)
(/.f64 re im)
re
im
#s(literal 1/2 binary64)

Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)
(*.f64 (/.f64 re im) re)
(/.f64 re im)
re
im
#s(literal 1/2 binary64)

localize146.0ms (3.3%)

Memory

-16.9MiB live, 31.6MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
accuracy	0	(/.f64 re im)
accuracy	0.1875	(*.f64 (/.f64 re im) re)
accuracy	0.19520630237801292	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))

Samples

140.0ms

256×

valid

Compiler

Compiled 30 to 10 computations (66.7% saved)

Precisions

Click to see histograms. Total time spent on operations: 134.0ms

ival-hypot: 127.0ms (95.1% of total)

ival-mult: 3.0ms (2.2% of total)

ival-div: 2.0ms (1.5% of total)

ival-add: 1.0ms (0.7% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

series8.0ms (0.2%)

Memory

17.0MiB live, 17.0MiB allocated

Counts

4 → 96

Calls

Call 1

Inputs
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())
#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())
#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())
#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())

Outputs
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (.f64 (/.f64 re im) re) (patch (.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
1.0ms	im	@	-inf	((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms	re	@	-inf	((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms	re	@	inf	((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms	im	@	inf	((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms	im	@	0	((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))

simplify226.0ms (5.1%)

Memory

-2.8MiB live, 225.6MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	111	788
1	302	788
2	977	786
3	3647	750
4	7514	750
0	8243	700

Stop Event

1×	iter limit
1×	node limit

Counts

96 → 89

Calls

Call 1

Inputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)

Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64))) im))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal -1/8 binary64)) (/.f64 re (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 (/.f64 im re) #s(literal 1/2 binary64)) im re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(* 1/2 (/ (pow re 2) im))
(.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) (neg.f64 re) (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(* 1/2 (/ (pow re 2) im))
(.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64))) re))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(* 1/2 (/ (pow re 2) im))
(.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (.f64 re re) #s(literal 1/2 binary64) (.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (.f64 re re) #s(literal 1/2 binary64) (.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (.f64 re re) #s(literal 1/2 binary64) (.f64 im im)) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) im (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))) (neg.f64 im)))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)

rewrite226.0ms (5.1%)

Memory

-20.2MiB live, 270.7MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	11	33
0	15	33
1	58	33
2	418	33
3	4804	33
0	8212	28

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

4 → 158

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(*.f64 (/.f64 re im) re)
(/.f64 re im)

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval75.0ms (1.7%)

Memory: 23.7MiB live, 60.3MiB allocated
Compiler: Compiled 4 608 to 704 computations (84.7% saved)

prune14.0ms (0.3%)

Memory

-6.3MiB live, 31.1MiB allocated

Pruning

6 alts after pruning (0 fresh and 6 done)

	Pruned	Kept	Total
New	247	0	247
Fresh	0	0	0
Picked	0	1	1
Done	0	5	5
Total	247	6	253

Accuracy

100.0%

Counts

253 → 6

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 re im)
✓	54.1%	(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓	4.9%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓	53.4%	(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
✓	99.7%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
✓	1.8%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

Compiler

Compiled 90 to 56 computations (37.8% saved)

regimes25.0ms (0.6%)

Memory

-0.6MiB live, 42.0MiB allocated

Counts

9 → 1

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 re im)

Outputs
(hypot.f64 re im)

Calls

6 calls:

7.0ms	(+.f64 (.f64 re re) (.f64 im im))
4.0ms	im
3.0ms	re
3.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
3.0ms	(*.f64 im im)

Results

Accuracy	Segments	Branch
100.0%	1	`re`
100.0%	1	`im`
100.0%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
100.0%	1	`(+.f64 (.f64 re re) (.f64 im im))`
100.0%	1	`(*.f64 re re)`
100.0%	1	`(*.f64 im im)`

Compiler

Compiled 23 to 21 computations (8.7% saved)

regimes42.0ms (1%)

Memory

2.4MiB live, 40.1MiB allocated

Counts

8 → 1

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))

Calls

6 calls:

26.0ms	(+.f64 (.f64 re re) (.f64 im im))
3.0ms	re
3.0ms	im
3.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
3.0ms	(*.f64 im im)

Results

Accuracy	Segments	Branch
99.7%	1	`re`
99.7%	1	`im`
99.7%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.7%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.7%	1	`(*.f64 re re)`
99.7%	1	`(*.f64 im im)`

Compiler

Compiled 23 to 21 computations (8.7% saved)

regimes43.0ms (1%)

Memory

-9.3MiB live, 28.3MiB allocated

Counts

5 → 1

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))

Outputs
(sqrt.f64 (fma.f64 im im (*.f64 re re)))

Calls

6 calls:

31.0ms	im
3.0ms	re
2.0ms	(+.f64 (.f64 re re) (.f64 im im))
2.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
2.0ms	(*.f64 im im)

Results

Accuracy	Segments	Branch
54.1%	1	`re`
54.1%	1	`im`
54.1%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
54.1%	1	`(+.f64 (.f64 re re) (.f64 im im))`
54.1%	1	`(*.f64 re re)`
54.1%	1	`(*.f64 im im)`

Compiler

Compiled 23 to 21 computations (8.7% saved)

regimes11.0ms (0.3%)

Memory

27.5MiB live, 27.5MiB allocated

Counts

3 → 1

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))

Outputs
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))

Calls

6 calls:

2.0ms	im
2.0ms	re
2.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
2.0ms	(+.f64 (.f64 re re) (.f64 im im))
2.0ms	(*.f64 im im)

Results

Accuracy	Segments	Branch
53.4%	1	`im`
53.4%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
53.4%	1	`(+.f64 (.f64 re re) (.f64 im im))`
53.4%	1	`(*.f64 im im)`
53.4%	1	`re`
53.4%	1	`(*.f64 re re)`

Compiler

Compiled 23 to 21 computations (8.7% saved)

regimes12.0ms (0.3%)

Memory

-14.7MiB live, 21.3MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

Calls

6 calls:

5.0ms	(*.f64 re re)
1.0ms	re
1.0ms	im
1.0ms	(+.f64 (.f64 re re) (.f64 im im))
1.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Results

Accuracy	Segments	Branch
1.8%	1	`im`
1.8%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
1.8%	1	`(+.f64 (.f64 re re) (.f64 im im))`
1.8%	1	`(*.f64 im im)`
1.8%	1	`re`
1.8%	1	`(*.f64 re re)`

Compiler

Compiled 23 to 21 computations (8.7% saved)

simplify30.0ms (0.7%)

Memory

7.7MiB live, 51.3MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	20	50
1	25	50
2	27	50
3	28	50

Stop Event

1×

saturated

Calls

Call 1

Inputs
(hypot.f64 re im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

Outputs
(hypot.f64 re im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

soundness606.0ms (13.6%)

Memory

-13.1MiB live, 504.2MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	62
0	23	62
1	91	62
2	647	62
0	8182	52
0	104	620
1	296	620
2	953	618
3	3667	584
4	6426	582
0	8051	530
0	6	21
0	10	21
1	29	21
2	196	21
3	1788	21
0	8624	15

Stop Event

1×	done
1×	iter limit
1×	node limit
1×	iter limit
1×	iter limit
1×	node limit
1×	iter limit
1×	node limit
1×	iter limit

Compiler

Compiled 76 to 51 computations (32.9% saved)

preprocess37.0ms (0.8%)

Memory

16.1MiB live, 92.3MiB allocated

Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 88 to 62 computations (29.5% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze0.0ms (0%)

sample699.0ms (15.7%)

explain200.0ms (4.5%)

preprocess30.0ms (0.7%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify3.0ms (0.1%)

localize38.0ms (0.8%)

series9.0ms (0.2%)

simplify190.0ms (4.3%)

rewrite255.0ms (5.7%)

eval76.0ms (1.7%)

prune9.0ms (0.2%)

simplify89.0ms (2%)

localize37.0ms (0.8%)

series9.0ms (0.2%)

simplify245.0ms (5.5%)

rewrite176.0ms (4%)

eval146.0ms (3.3%)

prune26.0ms (0.6%)

simplify5.0ms (0.1%)

localize40.0ms (0.9%)

series22.0ms (0.5%)

simplify192.0ms (4.3%)

rewrite197.0ms (4.4%)

eval62.0ms (1.4%)

prune179.0ms (4%)

simplify4.0ms (0.1%)

localize146.0ms (3.3%)

series8.0ms (0.2%)

simplify226.0ms (5.1%)

rewrite226.0ms (5.1%)

eval75.0ms (1.7%)

prune14.0ms (0.3%)

regimes25.0ms (0.6%)

regimes42.0ms (1%)

regimes43.0ms (1%)

regimes11.0ms (0.3%)

regimes12.0ms (0.3%)

simplify30.0ms (0.7%)

soundness606.0ms (13.6%)

preprocess37.0ms (0.8%)

end0.0ms (0%)

Profiling