Metrics for math.abs on complex

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated; 0ms collecting garbage

analyze0.0ms (0%)

Memory

0.7MiB live, 0.7MiB allocated; 0ms collecting garbage

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)

sample625.0ms (37.2%)

Memory

58.8MiB live, 930.3MiB allocated; 267ms collecting garbage

Samples

410.0ms

8 256×

valid

Precisions

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

ival-hypot: 169.0ms (99% of total)

adjust: 2.0ms (1.2% of total)

Bogosity

preprocess128.0ms (7.6%)

Memory

-52.4MiB live, 53.2MiB allocated; 37ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	50
1	53	50
2	125	50
3	175	50
4	399	50
5	1995	50
6	4647	50

Stop Event

1×	node-limit

Alt Table

Click to see full alt table

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

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 12 to 12 computations (0% saved)

series6.0ms (0.4%)

Memory

9.1MiB live, 9.1MiB allocated; 0ms collecting garbage

Counts

6 → 33

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
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))

Calls

6 calls:

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

rewrite244.0ms (14.5%)

Memory

43.9MiB live, 177.9MiB allocated; 16ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	147	822
0	150	782
1	783	742
0	7933	572

Stop Event

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

Counts

39 → 232

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
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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
(.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (hypot.f64 (.f64 (.f64 re re) re) (.f64 (.f64 im im) im)) (sqrt.f64 (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (hypot.f64 (.f64 (.f64 re re) re) (.f64 (.f64 im im) im)) (sqrt.f64 (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 re))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) re)
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 im))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) im)
(hypot.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 re)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (neg.f64 re) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (neg.f64 re) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (exp.f64 (log.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (neg.f64 im) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 im (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 re (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)) (pow.f64 (.f64 (neg.f64 im) im) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 re re) re) re (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (*.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)))) (neg.f64 (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)))) (neg.f64 (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 im re) (-.f64 im re))) (.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (fma.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re))) (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (fma.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re))) (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (.f64 (neg.f64 re) #s(literal -1 binary64)) re (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 (neg.f64 re) #s(literal -1 binary64)) re (.f64 im im))
(fma.f64 (.f64 (neg.f64 im) #s(literal -1 binary64)) im (.f64 re re))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 #s(literal 1 binary64) (neg.f64 im)) (*.f64 re re))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 im) (.f64 re re))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 #s(literal 1 binary64) (neg.f64 re)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 #s(literal 1 binary64) (neg.f64 re)) (*.f64 im im))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 re) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 re) (.f64 im im))
(fma.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(fma.f64 (.f64 (neg.f64 re) re) #s(literal -1 binary64) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 (neg.f64 re) re) #s(literal -1 binary64) (.f64 im im))
(fma.f64 (.f64 (neg.f64 im) im) #s(literal -1 binary64) (.f64 re re))
(fma.f64 (neg.f64 re) (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 re) (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 im im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 im) (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 re re))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 #s(literal -1 binary64) (.f64 (neg.f64 re) re) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 #s(literal -1 binary64) (.f64 (neg.f64 re) re) (.f64 im im))
(fma.f64 #s(literal -1 binary64) (.f64 (neg.f64 im) im) (.f64 re re))
(fma.f64 #s(literal 1 binary64) (.f64 re re) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 #s(literal 1 binary64) (.f64 re re) (.f64 im im))
(fma.f64 #s(literal 1 binary64) (.f64 im im) (.f64 re re))
(fma.f64 (.f64 re re) #s(literal 1 binary64) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 re re) #s(literal 1 binary64) (.f64 im im))
(fma.f64 (.f64 im im) #s(literal 1 binary64) (.f64 re re))
(fma.f64 im (.f64 #s(literal -1 binary64) (neg.f64 im)) (.f64 re re))
(fma.f64 im im (*.f64 re re))
(fma.f64 re (.f64 #s(literal -1 binary64) (neg.f64 re)) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 re (.f64 #s(literal -1 binary64) (neg.f64 re)) (.f64 im im))
(fma.f64 re re (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(-.f64 (.f64 im im) (.f64 (neg.f64 re) re))
(+.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im)) (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)) (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)) (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re))))) (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im)) (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re))))))
(+.f64 (.f64 re re) (.f64 (neg.f64 (neg.f64 im)) im))
(+.f64 (.f64 re re) (.f64 im im))
(+.f64 (.f64 im im) (.f64 re re))
(.f64 (.f64 (neg.f64 re) #s(literal -1 binary64)) re)
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 re))
(.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(.f64 (.f64 (neg.f64 re) re) #s(literal -1 binary64))
(.f64 (neg.f64 re) (.f64 (neg.f64 re) #s(literal 1 binary64)))
(*.f64 (neg.f64 re) (neg.f64 re))
(.f64 #s(literal -1 binary64) (.f64 (neg.f64 re) re))
(.f64 #s(literal 1 binary64) (.f64 re re))
(.f64 (.f64 re re) #s(literal 1 binary64))
(.f64 re (.f64 #s(literal -1 binary64) (neg.f64 re)))
(*.f64 re re)
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(pow.f64 (.f64 (.f64 (*.f64 re re) re) re) #s(literal 1/2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(/.f64 (.f64 (.f64 re re) #s(literal 2 binary64)) #s(literal 2 binary64))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 re re)) #s(literal 2 binary64))
(neg.f64 (*.f64 (neg.f64 re) re))
(sqrt.f64 (.f64 (.f64 (*.f64 re re) re) re))
(fabs.f64 (*.f64 re re))
(exp.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 re) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 re) #s(literal 2 binary64) #s(literal 0 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
re
(.f64 (.f64 (neg.f64 im) #s(literal -1 binary64)) im)
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 im))
(.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)))
(.f64 (.f64 (neg.f64 im) im) #s(literal -1 binary64))
(.f64 (neg.f64 im) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(*.f64 (neg.f64 im) (neg.f64 im))
(.f64 #s(literal -1 binary64) (.f64 (neg.f64 im) im))
(.f64 #s(literal 1 binary64) (.f64 im im))
(.f64 (.f64 im im) #s(literal 1 binary64))
(.f64 im (.f64 #s(literal -1 binary64) (neg.f64 im)))
(*.f64 im im)
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 2 binary64))
(pow.f64 (.f64 (.f64 (*.f64 im im) im) im) #s(literal 1/2 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(/.f64 (.f64 (.f64 im im) #s(literal 2 binary64)) #s(literal 2 binary64))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 im im)) #s(literal 2 binary64))
(neg.f64 (*.f64 (neg.f64 im) im))
(sqrt.f64 (.f64 (.f64 (*.f64 im im) im) im))
(fabs.f64 (*.f64 im im))
(exp.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))))
im
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) re im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (fma.f64 (.f64 re (/.f64 re (.f64 (.f64 im im) im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) re) re im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (fma.f64 (.f64 (fma.f64 (.f64 re (/.f64 re (pow.f64 im #s(literal 5 binary64)))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (.f64 (*.f64 im im) im))) re) re (/.f64 #s(literal 1/2 binary64) im)) re) re im))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx re re)
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im (/.f64 im (*.f64 re re))) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))) re re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 im (/.f64 im (.f64 re re))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (.f64 (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)) re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64) #s(literal 1 binary64)))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 re (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 im (/.f64 im (.f64 re re))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))) re)))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (fma.f64 (.f64 im (/.f64 im (.f64 (.f64 re re) re))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) im) im re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (fma.f64 (.f64 (fma.f64 (.f64 im (/.f64 im (pow.f64 re #s(literal 5 binary64)))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (.f64 (*.f64 re re) re))) im) im (/.f64 #s(literal 1/2 binary64) re)) im) im re))
#s(approx (* im im) (*.f64 im im))
#s(approx im im)
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64))) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 im (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 re (/.f64 re (.f64 im im))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) im))
#s(approx (+ (* re re) (* im im)) (.f64 (.f64 (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)) im) im))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (fma.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64)))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 im (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 re (/.f64 re (.f64 im im))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) im)))

eval34.0ms (2.1%)

Memory: 1.1MiB live, 51.3MiB allocated; 11ms collecting garbage
Compiler: Compiled 1 556 to 579 computations (62.8% saved)

prune10.0ms (0.6%)

Memory

-27.5MiB live, 14.5MiB allocated; 7ms collecting garbage

Pruning

8 alts after pruning (8 fresh and 0 done)

	Pruned	Kept	Total
New	217	8	225
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	218	8	226

Accuracy

100.0%

Counts

226 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(hypot.f64 re im)
▶	56.2%	(sqrt.f64 (fma.f64 re re (*.f64 im im)))
▶	6.8%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im re))
	99.4%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) re im))
	1.8%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
▶	1.2%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
	5.1%	#s(approx (sqrt (+ (* re re) (* im im))) re)
▶	98.8%	#s(approx (sqrt (+ (* re re) (* im im))) im)

Compiler

Compiled 120 to 120 computations (0% saved)

series12.0ms (0.7%)

Memory

29.6MiB live, 29.6MiB allocated; 0ms collecting garbage

Counts

14 → 42

Calls

Call 1

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

Outputs
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* 1/2 (/ (pow im 2) re))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)))
#s(approx (* (/ 1/2 re) im) #s(hole binary64 (* 1/2 (/ im re))))
#s(approx (/ 1/2 re) #s(hole binary64 (/ 1/2 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 re))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))

Calls

6 calls:

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

rewrite157.0ms (9.3%)

Memory

-25.9MiB live, 202.3MiB allocated; 24ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	185	884
0	195	830
1	921	797
0	8719	757

Stop Event

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

Counts

56 → 361

Calls

Call 1

Inputs
(hypot.f64 re im)
re
im
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
(*.f64 im im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im re))
(fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im re)
(*.f64 (/.f64 #s(literal 1/2 binary64) re) im)
(/.f64 #s(literal 1/2 binary64) re)
#s(literal 1/2 binary64)
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* 1/2 (/ (pow im 2) re))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)))
#s(approx (* (/ 1/2 re) im) #s(hole binary64 (* 1/2 (/ im re))))
#s(approx (/ 1/2 re) #s(hole binary64 (/ 1/2 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 re))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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
(.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (hypot.f64 (.f64 (.f64 re re) re) (.f64 (.f64 im im) im)) (sqrt.f64 (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (hypot.f64 (.f64 (.f64 im im) im) (.f64 (.f64 re re) re)) (sqrt.f64 (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 im))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) im)
(hypot.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 re))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 re)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 im)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 re)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 re)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 im)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (neg.f64 re) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (exp.f64 (log.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)))
re
im
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(neg.f64 im)
(.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (hypot.f64 (.f64 (.f64 re re) re) (.f64 (.f64 im im) im)) (sqrt.f64 (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (hypot.f64 (.f64 (.f64 im im) im) (.f64 (.f64 re re) re)) (sqrt.f64 (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 im)))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 im))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) im)
(hypot.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 re)))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 re))
(hypot.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 re)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 im)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 re)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 re)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 re)) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 im)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (neg.f64 re) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (exp.f64 (log.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (*.f64 #s(literal 1 binary64) (neg.f64 re)))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)) (pow.f64 (.f64 (neg.f64 im) im) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 re re) re) re (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (*.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im)))) (neg.f64 (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)))) (neg.f64 (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 im re) (-.f64 im re))) (.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (fma.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im))) (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (fma.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re))) (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (.f64 (neg.f64 re) #s(literal -1 binary64)) re (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 (neg.f64 re) #s(literal -1 binary64)) re (.f64 im im))
(fma.f64 (.f64 (neg.f64 im) #s(literal -1 binary64)) im (.f64 re re))
(fma.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 #s(literal 1 binary64) (neg.f64 re)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (.f64 #s(literal 1 binary64) (neg.f64 re)) (*.f64 im im))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 re) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 re) (.f64 im im))
(fma.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 #s(literal 1 binary64) (neg.f64 im)) (*.f64 re re))
(fma.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 im) (.f64 re re))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(fma.f64 (.f64 (neg.f64 re) re) #s(literal -1 binary64) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 (neg.f64 re) re) #s(literal -1 binary64) (.f64 im im))
(fma.f64 (.f64 (neg.f64 im) im) #s(literal -1 binary64) (.f64 re re))
(fma.f64 (neg.f64 re) (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 re) (.f64 (neg.f64 re) #s(literal 1 binary64)) (.f64 im im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 #s(literal -1 binary64) (.f64 (neg.f64 re) re) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 #s(literal -1 binary64) (.f64 (neg.f64 re) re) (.f64 im im))
(fma.f64 #s(literal -1 binary64) (.f64 (neg.f64 im) im) (.f64 re re))
(fma.f64 #s(literal 1 binary64) (.f64 re re) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 #s(literal 1 binary64) (.f64 re re) (.f64 im im))
(fma.f64 #s(literal 1 binary64) (.f64 im im) (.f64 re re))
(fma.f64 (.f64 re re) #s(literal 1 binary64) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (.f64 re re) #s(literal 1 binary64) (.f64 im im))
(fma.f64 (.f64 im im) #s(literal 1 binary64) (.f64 re re))
(fma.f64 (neg.f64 im) (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 re re))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 im (.f64 #s(literal -1 binary64) (neg.f64 im)) (.f64 re re))
(fma.f64 im im (*.f64 re re))
(fma.f64 re (.f64 #s(literal -1 binary64) (neg.f64 re)) (.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 re (.f64 #s(literal -1 binary64) (neg.f64 re)) (.f64 im im))
(fma.f64 re re (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(-.f64 (.f64 im im) (.f64 (neg.f64 re) re))
(+.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)) (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re))))) (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im)) (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (.f64 (+.f64 im re) (-.f64 im re))))))
(+.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 im im)) (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 re re)) (fma.f64 (.f64 (.f64 im im) im) im (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (.f64 re re) (.f64 (neg.f64 (neg.f64 im)) im))
(+.f64 (.f64 re re) (.f64 im im))
(+.f64 (.f64 im im) (.f64 re re))
(.f64 (.f64 (neg.f64 im) #s(literal -1 binary64)) im)
(.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 im))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)))
(.f64 (.f64 (neg.f64 im) im) #s(literal -1 binary64))
(.f64 #s(literal -1 binary64) (.f64 (neg.f64 im) im))
(.f64 #s(literal 1 binary64) (.f64 im im))
(.f64 (.f64 im im) #s(literal 1 binary64))
(.f64 (neg.f64 im) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(*.f64 (neg.f64 im) (neg.f64 im))
(.f64 im (.f64 #s(literal -1 binary64) (neg.f64 im)))
(*.f64 im im)
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 2 binary64))
(pow.f64 (.f64 (.f64 (*.f64 im im) im) im) #s(literal 1/2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 im #s(literal 2 binary64))
(/.f64 (.f64 (.f64 im im) #s(literal 2 binary64)) #s(literal 2 binary64))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 im im)) #s(literal 2 binary64))
(neg.f64 (*.f64 (neg.f64 im) im))
(sqrt.f64 (.f64 (.f64 (*.f64 im im) im) im))
(fabs.f64 (*.f64 im im))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 im re) re))
(/.f64 (fma.f64 (pow.f64 (/.f64 (.f64 im im) re) #s(literal 3 binary64)) #s(literal 1/8 binary64) (.f64 (.f64 re re) re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im) (.f64 re (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 re re) re) (pow.f64 (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)) #s(literal 3 binary64))) (fma.f64 re re (fma.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im) (.f64 re (.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re))))))
(/.f64 (neg.f64 (-.f64 (.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (.f64 re re))) (neg.f64 (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re)))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (/.f64 (.f64 im im) re) #s(literal 3 binary64)) #s(literal 1/8 binary64) (.f64 (.f64 re re) re))) (neg.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im) (.f64 re (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (.f64 re re) (.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)))) (neg.f64 (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) re (pow.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 re re (.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re)))))
(/.f64 (-.f64 (.f64 re re) (.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im))) (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64))))
(/.f64 (-.f64 (.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (.f64 re re)) (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re))
(/.f64 (fma.f64 (.f64 re re) re (pow.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) #s(literal 3 binary64))) (fma.f64 re re (.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re))))
(fma.f64 (.f64 (.f64 im im) (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64) re)
(fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) (neg.f64 im)) (neg.f64 im) re)
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 im re) re)
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (*.f64 im im) re)
(fma.f64 (/.f64 #s(literal 1 binary64) re) (.f64 (.f64 im im) #s(literal 1/2 binary64)) re)
(fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re)
(fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) re) re)
(fma.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) #s(literal 1 binary64) re)
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im re)
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re) re)
(fma.f64 #s(literal 1/2 binary64) (.f64 (/.f64 #s(literal 1 binary64) re) (.f64 im im)) re)
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 im re) im) re)
(fma.f64 #s(literal 1/2 binary64) (.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) re)) re)
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(fma.f64 (neg.f64 im) (*.f64 (neg.f64 im) (/.f64 #s(literal 1/2 binary64) re)) re)
(fma.f64 im (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) re)
(-.f64 (/.f64 (.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re)) (/.f64 (.f64 re re) (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re)))
(-.f64 (/.f64 (.f64 re re) (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))) (/.f64 (.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))))
(-.f64 re (.f64 (neg.f64 (.f64 (/.f64 #s(literal 1/2 binary64) re) im)) im))
(-.f64 re (.f64 (neg.f64 im) (.f64 (/.f64 #s(literal 1/2 binary64) re) im)))
(-.f64 re (.f64 (/.f64 #s(literal -1/2 binary64) re) (.f64 im im)))
(-.f64 re (.f64 (neg.f64 (/.f64 (.f64 im im) re)) #s(literal 1/2 binary64)))
(-.f64 re (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) re)))
(+.f64 (/.f64 (pow.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) #s(literal 3 binary64)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im) (.f64 re (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))))) (/.f64 (.f64 (.f64 re re) re) (fma.f64 (/.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im) (.f64 re (-.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))))))
(+.f64 (/.f64 (.f64 (.f64 re re) re) (fma.f64 re re (.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re)))) (/.f64 (pow.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) #s(literal 3 binary64)) (fma.f64 re re (.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) (-.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re)))))
(+.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) re)
(+.f64 re (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
(.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 #s(literal 1/2 binary64) re) im)
(.f64 (/.f64 #s(literal 1 binary64) re) (.f64 #s(literal 1/2 binary64) im))
(*.f64 (/.f64 im re) #s(literal 1/2 binary64))
(.f64 (.f64 (/.f64 #s(literal 1/2 binary64) re) im) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (.f64 (/.f64 #s(literal 1 binary64) re) im))
(*.f64 #s(literal 1/2 binary64) (/.f64 im re))
(*.f64 im (/.f64 #s(literal 1/2 binary64) re))
(/.f64 (*.f64 #s(literal 1/2 binary64) (neg.f64 im)) (neg.f64 re))
(/.f64 (*.f64 im #s(literal -1/2 binary64)) (neg.f64 re))
(/.f64 (*.f64 #s(literal -1/2 binary64) im) (neg.f64 re))
(/.f64 (*.f64 (neg.f64 im) #s(literal 1/2 binary64)) (neg.f64 re))
(/.f64 (*.f64 im #s(literal 1/2 binary64)) re)
(/.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) im)) (neg.f64 re))
(/.f64 (*.f64 #s(literal 1/2 binary64) im) re)
(*.f64 (/.f64 #s(literal 1/2 binary64) re) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) re))
(/.f64 (/.f64 #s(literal -1/2 binary64) re) #s(literal -1 binary64))
(/.f64 #s(literal -1/2 binary64) (neg.f64 re))
(/.f64 #s(literal 1/2 binary64) (neg.f64 (neg.f64 re)))
(/.f64 #s(literal 1/2 binary64) re)
(neg.f64 (/.f64 #s(literal -1/2 binary64) re))
#s(literal 1/2 binary64)
#s(approx (sqrt (+ (* re re) (* im im))) im)
#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 (fma.f64 (.f64 re (/.f64 re (.f64 (.f64 im im) im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) re) re im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (fma.f64 (.f64 (fma.f64 (.f64 re (/.f64 re (pow.f64 im #s(literal 5 binary64)))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (.f64 (*.f64 im im) im))) re) re (/.f64 #s(literal 1/2 binary64) im)) re) re im))
#s(approx re re)
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) (/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) (.f64 re re)) re))
#s(approx (* (/ 1/2 re) im) (*.f64 (/.f64 #s(literal 1/2 binary64) re) im))
#s(approx (/ 1/2 re) (/.f64 #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64))) re re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 im (/.f64 im (.f64 re re))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64)))) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (.f64 (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)) re) re))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) re)
#s(approx (+ (* (* (/ 1/2 re) im) im) re) (.f64 (fma.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64))) re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 re (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 im (/.f64 im (.f64 re re))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (.f64 (.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64)))) re)))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) (.f64 (neg.f64 re) (fma.f64 #s(literal -1/2 binary64) (.f64 im (/.f64 im (*.f64 re re))) #s(literal -1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (fma.f64 (.f64 im (/.f64 im (.f64 (.f64 re re) re))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) im) im re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (.f64 (fma.f64 (.f64 (fma.f64 (.f64 im (/.f64 im (pow.f64 re #s(literal 5 binary64)))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (.f64 (*.f64 re re) re))) im) im (/.f64 #s(literal 1/2 binary64) re)) im) im re))
#s(approx im im)
#s(approx (neg im) (neg.f64 im))
#s(approx (* im im) (*.f64 im im))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) (fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (.f64 (.f64 re re) (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/8 binary64) (.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64))) im im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 im (fma.f64 (.f64 (.f64 re re) (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 re (/.f64 re (.f64 im im))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) im))
#s(approx (+ (* re re) (* im im)) (.f64 (.f64 (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)) im) im))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) (.f64 (.f64 (-.f64 (/.f64 re (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) re)) im) im))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64)) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/8 binary64) (.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64))) im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 im (fma.f64 (.f64 (.f64 re re) (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (.f64 re (/.f64 re (.f64 im im))) #s(literal 3 binary64)) #s(literal 1/16 binary64) (.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) im)))

eval29.0ms (1.7%)

Memory: 2.2MiB live, 46.2MiB allocated; 4ms collecting garbage
Compiler: Compiled 1 978 to 738 computations (62.7% saved)

prune6.0ms (0.3%)

Memory

12.8MiB live, 12.8MiB allocated; 0ms collecting garbage

Pruning

8 alts after pruning (3 fresh and 5 done)

	Pruned	Kept	Total
New	266	1	267
Fresh	1	2	3
Picked	0	5	5
Done	0	0	0
Total	267	8	275

Accuracy

100.0%

Counts

275 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 re im)
✓	56.2%	(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓	6.8%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im re))
▶	99.4%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) re im))
▶	1.8%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
✓	1.2%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
▶	5.1%	#s(approx (sqrt (+ (* re re) (* im im))) #s(approx (+ (* (* (/ 1/2 re) im) im) re) re))
✓	98.8%	#s(approx (sqrt (+ (* re re) (* im im))) im)

Compiler

Compiled 66 to 66 computations (0% saved)

series10.0ms (0.6%)

Memory

15.9MiB live, 15.9MiB allocated; 0ms collecting garbage

Counts

11 → 43

Calls

Call 1

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

Outputs
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* 1/2 (/ (pow im 2) re))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)))
#s(approx re #s(hole binary64 re))
#s(approx (neg re) #s(hole binary64 (* -1 re)))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 im))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (* (/ 1/2 im) re) #s(hole binary64 (* 1/2 (/ re im))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 re))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* 1/2 (/ (pow re 2) im))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)))
#s(approx (/ 1/2 im) #s(hole binary64 (/ 1/2 im)))
#s(approx im #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))))

Calls

6 calls:

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

rewrite223.0ms (13.3%)

Memory

-19.8MiB live, 183.0MiB allocated; 127ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	197	1085
0	204	1033
1	975	996
0	8846	810

Stop Event

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

Counts

54 → 105

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* re re) (* im im))) #s(approx (+ (* (* (/ 1/2 re) im) im) re) re))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) re)
re
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) re im))
(fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) re im)
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* 1/2 (/ (pow im 2) re))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)))
#s(approx re #s(hole binary64 re))
#s(approx (neg re) #s(hole binary64 (* -1 re)))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 im))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (* (/ 1/2 im) re) #s(hole binary64 (* 1/2 (/ re im))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 re))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* 1/2 (/ (pow re 2) im))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)))
#s(approx (/ 1/2 im) #s(hole binary64 (/ 1/2 im)))
#s(approx im #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (* (/ 1/2 re) im) im) re) #s(hole binary64 (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (* (/ 1/2 im) re) re) im) #s(hole binary64 (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))))

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

eval9.0ms (0.5%)

Memory: 17.6MiB live, 17.6MiB allocated; 0ms collecting garbage
Compiler: Compiled 922 to 368 computations (60.1% saved)

prune22.0ms (1.3%)

Memory

-47.5MiB live, 13.0MiB allocated; 17ms collecting garbage

Pruning

8 alts after pruning (0 fresh and 8 done)

	Pruned	Kept	Total
New	89	0	89
Fresh	0	0	0
Picked	0	3	3
Done	0	5	5
Total	89	8	97

Accuracy

100.0%

Counts

97 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 re im)
✓	56.2%	(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓	6.8%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im re))
✓	99.4%	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) re im))
✓	1.8%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
✓	1.2%	#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
✓	5.1%	#s(approx (sqrt (+ (* re re) (* im im))) #s(approx (+ (* (* (/ 1/2 re) im) im) re) re))
✓	98.8%	#s(approx (sqrt (+ (* re re) (* im im))) im)

Compiler

Compiled 122 to 101 computations (17.2% saved)

regimes17.0ms (1%)

Memory

33.3MiB live, 33.3MiB allocated; 0ms collecting garbage

Counts

10 → 1

Calls

Call 1

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

Outputs
(hypot.f64 re im)

Calls

6 calls:

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

Results

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

Compiler

Compiled 17 to 21 computations (-23.5% saved)

regimes18.0ms (1.1%)

Memory

-14.5MiB live, 31.5MiB allocated; 4ms collecting garbage

Counts

9 → 1

Calls

Call 1

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

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

Calls

6 calls:

5.0ms	re
3.0ms	im
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
99.4%	1	`(*.f64 im im)`
99.4%	1	`(*.f64 re re)`
99.4%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.4%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.4%	1	`re`
99.4%	1	`im`

Compiler

Compiled 17 to 21 computations (-23.5% saved)

regimes16.0ms (0.9%)

Memory

-18.9MiB live, 27.2MiB allocated; 3ms collecting garbage

Accuracy

Total -62.5b remaining (-8160.1%)

Threshold costs -62.5b (-8160.1%)

Counts

7 → 1

Calls

Call 1

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

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

Calls

6 calls:

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

Results

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

Compiler

Compiled 17 to 21 computations (-23.5% saved)

derivations84.0ms (5%)

Memory

25.3MiB live, 72.2MiB allocated; 2ms collecting garbage

Stop Event

1×

done

Compiler

Compiled 17 to 13 computations (23.5% saved)

preprocess30.0ms (1.8%)

Memory: -0.4MiB live, 49.8MiB allocated; 5ms collecting garbage
Compiler: Compiled 149 to 145 computations (2.7% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated; 0ms collecting garbage

start0.0ms (0%)

analyze0.0ms (0%)

sample625.0ms (37.2%)

preprocess128.0ms (7.6%)

series6.0ms (0.4%)

rewrite244.0ms (14.5%)

eval34.0ms (2.1%)

prune10.0ms (0.6%)

series12.0ms (0.7%)

rewrite157.0ms (9.3%)

eval29.0ms (1.7%)

prune6.0ms (0.3%)

series10.0ms (0.6%)

rewrite223.0ms (13.3%)

eval9.0ms (0.5%)

prune22.0ms (1.3%)

regimes17.0ms (1%)

regimes18.0ms (1.1%)

regimes16.0ms (0.9%)

derivations84.0ms (5%)

preprocess30.0ms (1.8%)

end0.0ms (0%)

Profiling