math.abs on complex

Time bar (total: 1.6s)

start0.0ms (0%)

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

analyze0.0ms (0%)

Memory
0.6MiB live, 0.6MiB allocated; 0ms collecting garbage
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
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)

sample691.0ms (42.2%)

Memory
-19.9MiB live, 763.0MiB allocated; 212ms collecting garbage
Samples
485.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 176.0ms
ival-hypot: 175.0ms (99.3% of total)
adjust: 1.0ms (0.6% of total)
Bogosity

preprocess103.0ms (6.3%)

Memory
-4.7MiB live, 42.4MiB allocated; 4ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01850
15350
212550
317550
439950
5199550
6464750
Stop Event
1×node-limit
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶50.9%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 16 to 12 computations (25% saved)

series6.0ms (0.4%)

Memory
9.1MiB live, 9.1MiB allocated; 0ms collecting garbage
Counts
6 → 29
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 (+ 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) (+ 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 #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:

TimeVariablePoint
1.0ms
re
inf
1.0ms
re
0
1.0ms
re
-inf
1.0ms
im
inf
1.0ms
im
-inf

rewrite214.0ms (13.1%)

Memory
7.1MiB live, 188.9MiB allocated; 48ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0143784
0147758
1765704
08071545
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
35 → 227
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 (+ 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) (+ 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 #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 re re (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(sqrt.f64 (fma.f64 re re (*.f64 im 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 (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 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 (*.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 (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 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)
(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)
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re)) (pow.f64 (*.f64 (neg.f64 im) im) #s(literal 3 binary64))) (fma.f64 (*.f64 re (*.f64 re re)) re (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re)))) (neg.f64 (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re)))) (neg.f64 (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (fma.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re))) (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re))) (fma.f64 (*.f64 re (*.f64 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 (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 (*.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 (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 im) im) #s(literal -1 binary64) (*.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 (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 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))
(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 im) 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 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 im (*.f64 #s(literal -1 binary64) (neg.f64 im)) (*.f64 re re))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 re re))
(-.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 (*.f64 im (*.f64 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 im (*.f64 im im)) im) (*.f64 im im)) (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re)) (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re)) (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im)) (fma.f64 (*.f64 re (*.f64 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 (neg.f64 re) #s(literal 1 binary64)) (*.f64 (neg.f64 re) #s(literal 1 binary64)))
(*.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 (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 re (*.f64 #s(literal -1 binary64) (neg.f64 re)))
(*.f64 re 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))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 re (*.f64 re re)) re) #s(literal 1/2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 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 re (*.f64 re re)) re))
(fabs.f64 (*.f64 re re))
(exp.f64 (fma.f64 (log.f64 re) #s(literal 2 binary64) #s(literal 0 binary64)))
(exp.f64 (+.f64 #s(literal 0 binary64) (*.f64 (log.f64 re) #s(literal 2 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 (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 (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 im (*.f64 #s(literal -1 binary64) (neg.f64 im)))
(*.f64 im im)
(*.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im (*.f64 im im)) im) #s(literal 1/2 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 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 im (*.f64 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))))
im
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (fma.f64 (*.f64 re (/.f64 re (*.f64 im (*.f64 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 im (*.f64 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 re re (*.f64 im im)))
#s(approx (* re re) (*.f64 re re))
#s(approx re 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 re (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 re re)) re)) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 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 (*.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 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 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 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 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 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (fma.f64 (*.f64 im (/.f64 im (*.f64 re (*.f64 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 re (*.f64 re re)))) im) im (/.f64 #s(literal 1/2 binary64) re)) im) im re))
#s(approx 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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)))

eval24.0ms (1.4%)

Memory
7.3MiB live, 52.3MiB allocated; 6ms collecting garbage
Compiler

Compiled 2 987 to 573 computations (80.8% saved)

prune6.0ms (0.4%)

Memory
28.3MiB live, 28.3MiB allocated; 0ms collecting garbage
Pruning

6 alts after pruning (6 fresh and 0 done)

PrunedKeptTotal
New2166222
Fresh000
Picked101
Done000
Total2176223
Accuracy
100.0%
Counts
223 → 6
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶100.0%
(hypot.f64 re im)
50.9%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
▶1.7%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
▶1.0%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
▶5.0%
#s(approx (sqrt (+ (* re re) (* im im))) re)
▶98.7%
#s(approx (sqrt (+ (* re re) (* im im))) im)
Compiler

Compiled 104 to 76 computations (26.9% saved)

series4.0ms (0.3%)

Memory
-37.1MiB live, 9.6MiB allocated; 3ms collecting garbage
Counts
9 → 24
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))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
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 (neg re) #s(hole binary64 (* -1 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 (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 #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 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 (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:

TimeVariablePoint
2.0ms
im
-inf
1.0ms
re
-inf
0.0ms
re
inf
0.0ms
im
inf
0.0ms
re
0

rewrite205.0ms (12.6%)

Memory
19.4MiB live, 306.0MiB allocated; 52ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0138605
0140573
1707525
07451489
Stop Event
1×iter-limit
1×iter-limit
1×node-limit
1×iter-limit
Counts
33 → 74
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))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
#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 (neg re) #s(hole binary64 (* -1 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 (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 #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 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 (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 re re (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(sqrt.f64 (fma.f64 re re (*.f64 im 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)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(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)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(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)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (neg.f64 im))
(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)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (neg.f64 re))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 re im)
(hypot.f64 re (neg.f64 im))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 im re)
(hypot.f64 im (neg.f64 re))
(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) im)
(hypot.f64 (neg.f64 re) (neg.f64 im))
(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) re)
(hypot.f64 (neg.f64 im) (neg.f64 re))
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
re
im
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) re)
#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)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(*.f64 re #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) re)
(neg.f64 re)
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (fma.f64 (*.f64 re (/.f64 re (*.f64 im (*.f64 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 im (*.f64 im im)))) re) re (/.f64 #s(literal 1/2 binary64) im)) re) re im))
#s(approx re re)
#s(approx (neg re) (neg.f64 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 re (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 re re)) re)) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (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) (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 re re)) re)) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) 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))) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 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))) (neg.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 re (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) (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 re re)) re)) #s(literal -1/8 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 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (fma.f64 (*.f64 im (/.f64 im (*.f64 re (*.f64 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 re (*.f64 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 (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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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 (exp.f64 (-.f64 (*.f64 (log.f64 re) #s(literal 6 binary64)) (*.f64 (log.f64 im) #s(literal 6 binary64)))) #s(literal 1/16 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 im im)) im)) #s(literal -1/8 binary64) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) 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))) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (fma.f64 im (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) (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 im im)) im)) #s(literal -1/8 binary64) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) im)))

eval6.0ms (0.4%)

Memory
13.7MiB live, 13.7MiB allocated; 0ms collecting garbage
Compiler

Compiled 1 005 to 191 computations (81% saved)

prune3.0ms (0.2%)

Memory
7.2MiB live, 7.2MiB allocated; 0ms collecting garbage
Pruning

6 alts after pruning (1 fresh and 5 done)

PrunedKeptTotal
New66066
Fresh011
Picked055
Done000
Total66672
Accuracy
100.0%
Counts
72 → 6
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓100.0%
(hypot.f64 re im)
▶50.9%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓1.7%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
✓1.0%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
✓5.0%
#s(approx (sqrt (+ (* re re) (* im im))) re)
✓98.7%
#s(approx (sqrt (+ (* re re) (* im im))) im)
Compiler

Compiled 52 to 38 computations (26.9% saved)

series14.0ms (0.9%)

Memory
-36.9MiB live, 7.6MiB allocated; 7ms collecting garbage
Counts
5 → 29
Calls
Call 1
Inputs
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
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 #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 #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:

TimeVariablePoint
1.0ms
im
inf
1.0ms
im
-inf
0.0ms
re
inf
0.0ms
re
-inf
0.0ms
im
0

rewrite169.0ms (10.3%)

Memory
49.4MiB live, 180.8MiB allocated; 39ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0142756
0145729
1762675
08054545
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
34 → 199
Calls
Call 1
Inputs
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
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 #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 #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 re re (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (hypot.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (sqrt.f64 (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(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 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 (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 (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 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 (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 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)
(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)
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re)) (pow.f64 (*.f64 (neg.f64 im) im) #s(literal 3 binary64))) (fma.f64 (*.f64 re (*.f64 re re)) re (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im)))) (neg.f64 (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im)))) (neg.f64 (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im))) (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im))) (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re 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)) 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 #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 im)) (neg.f64 (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 (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 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 (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 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))
(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 im (*.f64 #s(literal -1 binary64) (neg.f64 im)) (*.f64 re re))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 re re))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 re (*.f64 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 re (*.f64 re re)) re) (*.f64 re re)) (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im)) (fma.f64 (*.f64 re (*.f64 re re)) re (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 im im)) (fma.f64 (*.f64 im (*.f64 im im)) im (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) re) (*.f64 re re)) (fma.f64 (*.f64 im (*.f64 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))
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 im (*.f64 #s(literal -1 binary64) (neg.f64 im)))
(*.f64 im im)
(*.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im (*.f64 im im)) im) #s(literal 1/2 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 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 im (*.f64 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 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (fma.f64 (*.f64 re (/.f64 re (*.f64 im (*.f64 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 im (*.f64 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 re re (*.f64 im im)))
#s(approx re 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 re (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 re re)) re)) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 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 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 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 im (*.f64 im im)) im) (*.f64 (*.f64 re (*.f64 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 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (fma.f64 (*.f64 im (/.f64 im (*.f64 re (*.f64 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 re (*.f64 re re)))) im) im (/.f64 #s(literal 1/2 binary64) re)) im) im re))
#s(approx 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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 re (*.f64 re re)) re) (*.f64 (*.f64 im (*.f64 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)))

eval21.0ms (1.3%)

Memory
13.4MiB live, 56.2MiB allocated; 9ms collecting garbage
Compiler

Compiled 2 601 to 479 computations (81.6% saved)

prune8.0ms (0.5%)

Memory
-25.2MiB live, 17.6MiB allocated; 8ms collecting garbage
Pruning

6 alts after pruning (0 fresh and 6 done)

PrunedKeptTotal
New1890189
Fresh000
Picked011
Done055
Total1896195
Accuracy
100.0%
Counts
195 → 6
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓100.0%
(hypot.f64 re im)
✓50.9%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓1.7%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
✓1.0%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
✓5.0%
#s(approx (sqrt (+ (* re re) (* im im))) re)
✓98.7%
#s(approx (sqrt (+ (* re re) (* im im))) im)
Compiler

Compiled 112 to 57 computations (49.1% saved)

regimes27.0ms (1.6%)

Memory
-15.0MiB live, 45.0MiB allocated; 16ms collecting garbage
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))) (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)))
(hypot.f64 re im)
Outputs
(hypot.f64 re im)
Calls

6 calls:

15.0ms
(*.f64 re re)
2.0ms
im
2.0ms
re
2.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
2.0ms
(*.f64 im im)
Results
AccuracySegmentsBranch
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%1re
100.0%1im
Compiler

Compiled 23 to 21 computations (8.7% saved)

regimes16.0ms (1%)

Memory
3.2MiB live, 48.6MiB allocated; 6ms collecting garbage
Accuracy

Total -62.5b remaining (-7240.5%)

Threshold costs -62.5b (-7240.5%)

Counts
6 → 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))) (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 re re)
2.0ms
im
2.0ms
re
2.0ms
(*.f64 im im)
2.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
Results
AccuracySegmentsBranch
98.7%1(*.f64 im im)
98.7%1(*.f64 re re)
98.7%1(+.f64 (*.f64 re re) (*.f64 im im))
98.7%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
98.7%1re
98.7%1im
Compiler

Compiled 23 to 21 computations (8.7% saved)

derivations72.0ms (4.4%)

Memory
-3.5MiB live, 86.0MiB allocated; 13ms collecting garbage
Stop Event
1×done
Compiler

Compiled 13 to 8 computations (38.5% saved)

preprocess47.0ms (2.9%)

Memory
-0.1MiB live, 55.1MiB allocated; 41ms collecting garbage
Compiler

Compiled 99 to 74 computations (25.3% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...