Metrics for math.log10 on complex, real part

start0.0ms (0%)

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

analyze98.0ms (3.7%)

Memory

-29.5MiB live, 75.7MiB allocated; 45ms collecting garbage

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.9%	0.1%	0%	0%	0%	0
0%	0%	99.9%	0.1%	0%	0%	0%	1
0%	0%	99.9%	0.1%	0%	0%	0%	2
0%	0%	99.9%	0.1%	0%	0%	0%	3
0%	0%	99.9%	0.1%	0%	0%	0%	4
18.8%	18.7%	81.2%	0.1%	0%	0%	0%	5
34.4%	34.3%	65.6%	0.1%	0%	0%	0%	6
54.7%	54.6%	45.3%	0.1%	0%	0%	0%	7
64.8%	64.8%	35.1%	0.1%	0%	0%	0%	8
76.2%	76.1%	23.8%	0.1%	0%	0%	0%	9
81.8%	81.8%	18.1%	0.1%	0%	0%	0%	10
87.8%	87.7%	12.2%	0.1%	0%	0%	0%	11
90.8%	90.7%	9.2%	0.1%	0%	0%	0%	12

Compiler

Compiled 14 to 9 computations (35.7% saved)

sample847.0ms (31.7%)

Memory

61.9MiB live, 1 190.3MiB allocated; 216ms collecting garbage

Samples

596.0ms

8 256×

valid

Precisions

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

ival-hypot: 205.0ms (57.4% of total)

ival-log: 111.0ms (31.1% of total)

ival-div!: 39.0ms (10.9% of total)

adjust: 2.0ms (0.6% of total)

Bogosity

preprocess165.0ms (6.2%)

Memory

-35.6MiB live, 59.1MiB allocated; 8ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	28	74
1	78	72
2	161	72
3	230	72
4	498	72
5	2387	72
6	7160	72

Stop Event

1×	node-limit

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.3%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 20 to 20 computations (0% saved)

series15.0ms (0.6%)

Memory

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

Counts

10 → 81

Calls

Call 1

Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (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)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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)))
#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	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
3.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
3.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
2.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
1.0ms	re	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)

rewrite227.0ms (8.5%)

Memory

14.0MiB live, 340.2MiB allocated; 43ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	386	2730
0	395	2490
1	2203	2378
0	9842	1912

Stop Event

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

Counts

91 → 184

Calls

Call 1

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

eval23.0ms (0.8%)

Memory: -25.2MiB live, 65.8MiB allocated; 9ms collecting garbage
Compiler: Compiled 2 263 to 800 computations (64.6% saved)

prune6.0ms (0.2%)

Memory

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

Pruning

7 alts after pruning (7 fresh and 0 done)

	Pruned	Kept	Total
New	160	7	167
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	161	7	168

Accuracy

99.3%

Counts

168 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
	50.3%	(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
▶	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
	50.3%	(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
▶	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
▶	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
▶	9.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
▶	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 144 to 144 computations (0% saved)

series74.0ms (2.8%)

Memory

-45.7MiB live, 27.4MiB allocated; 100ms collecting garbage

Counts

21 → 76

Calls

Call 1

Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) im)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))
#s(approx (sqrt (+ (* re re) (* im im))) re)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (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)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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)))
#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
66.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re))
1.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re))
1.0ms	re	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re))
1.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re))
1.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re))

rewrite580.0ms (21.7%)

Memory

33.7MiB live, 268.1MiB allocated; 39ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	387	2351
0	410	2105
1	2174	1997
0	9542	1915

Stop Event

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

Counts

97 → 149

Calls

Call 1

Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) im)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))
#s(approx (sqrt (+ (* re re) (* im im))) re)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (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)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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)))
#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 (neg.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (hypot.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 im im))))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re im)
(hypot.f64 re (neg.f64 im))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(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) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(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) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(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
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) im)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))
#s(approx (sqrt (+ (* re re) (* im im))) re)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 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 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 im im))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 im im) (.f64 im im)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 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 (fma.f64 (/.f64 (.f64 re re) (.f64 im (.f64 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 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx re re)
#s(approx (neg re) (neg.f64 re))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (.f64 (.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (.f64 (exp.f64 (-.f64 (.f64 (log.f64 im) #s(literal 6 binary64)) (.f64 (log.f64 re) #s(literal 6 binary64)))) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 im im)) #s(literal 120 binary64)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 re (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 re (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 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 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (.f64 (.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (.f64 (exp.f64 (-.f64 (.f64 (log.f64 im) #s(literal 6 binary64)) (.f64 (log.f64 re) #s(literal 6 binary64)))) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 im im)) #s(literal 120 binary64)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 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 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 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 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 (.f64 im im) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 re re) (.f64 re re)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 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 (fma.f64 (/.f64 (.f64 im im) (.f64 re (.f64 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 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 re (.f64 re re)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx im im)
#s(approx (neg im) (neg.f64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (.f64 (exp.f64 (-.f64 (.f64 (log.f64 re) #s(literal 6 binary64)) (.f64 (log.f64 im) #s(literal 6 binary64)))) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 im im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 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 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (.f64 (exp.f64 (-.f64 (.f64 (log.f64 re) #s(literal 6 binary64)) (.f64 (log.f64 im) #s(literal 6 binary64)))) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 im im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 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 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 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 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64))))

eval14.0ms (0.5%)

Memory: -7.7MiB live, 37.8MiB allocated; 6ms collecting garbage
Compiler: Compiled 1 688 to 530 computations (68.6% saved)

prune9.0ms (0.3%)

Memory

-20.6MiB live, 26.0MiB allocated; 3ms collecting garbage

Pruning

11 alts after pruning (6 fresh and 5 done)

	Pruned	Kept	Total
New	112	4	116
Fresh	0	2	2
Picked	0	5	5
Done	0	0	0
Total	112	11	123

Accuracy

99.6%

Counts

123 → 11

Alt Table

Click to see full alt table

Status	Accuracy	Program
	50.3%	(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
▶	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
▶	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
▶	9.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))) (log.f64 #s(literal 1/10 binary64)))
▶	98.4%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	50.3%	(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
✓	9.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 191 to 191 computations (0% saved)

series23.0ms (0.8%)

Memory

8.3MiB live, 62.8MiB allocated; 10ms collecting garbage

Counts

29 → 130

Calls

Call 1

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

Outputs
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow im 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (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)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow re 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))

Calls

6 calls:

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

rewrite189.0ms (7.1%)

Memory

4.1MiB live, 234.3MiB allocated; 60ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	594	4706
0	625	4273
1	3382	4061
0	9257	3377

Stop Event

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

Counts

159 → 261

Calls

Call 1

Inputs
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))
#s(approx (sqrt (+ (* re re) (* im im))) re)
re
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
(*.f64 im im)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow im 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (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)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow re 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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)))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))

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

eval23.0ms (0.9%)

Memory: -7.2MiB live, 38.2MiB allocated; 4ms collecting garbage
Compiler: Compiled 3 268 to 980 computations (70% saved)

prune6.0ms (0.2%)

Memory

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

Pruning

11 alts after pruning (1 fresh and 10 done)

	Pruned	Kept	Total
New	211	0	211
Fresh	0	1	1
Picked	0	5	5
Done	0	5	5
Total	211	11	222

Accuracy

99.6%

Counts

222 → 11

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.3%	(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
✓	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
✓	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
✓	9.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.4%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	50.3%	(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
✓	9.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 122 to 122 computations (0% saved)

series7.0ms (0.3%)

Memory

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

Counts

10 → 104

Calls

Call 1

Inputs
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)

Outputs
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow im 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (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)))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow re 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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)))
#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	im	@	inf	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) re (* im im) im (log 1/10) 1/10)
1.0ms	im	@	-inf	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) re (* im im) im (log 1/10) 1/10)
1.0ms	re	@	-inf	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) re (* im im) im (log 1/10) 1/10)
1.0ms	re	@	inf	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) re (* im im) im (log 1/10) 1/10)
1.0ms	re	@	0	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) re (* im im) im (log 1/10) 1/10)

rewrite156.0ms (5.8%)

Memory

5.9MiB live, 195.6MiB allocated; 53ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	457	3469
0	468	3138
1	2633	2969
0	8345	2467

Stop Event

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

Counts

114 → 193

Calls

Call 1

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

eval49.0ms (1.8%)

Memory: -12.4MiB live, 33.6MiB allocated; 3ms collecting garbage
Compiler: Compiled 2 604 to 889 computations (65.9% saved)

prune8.0ms (0.3%)

Memory

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

Pruning

11 alts after pruning (0 fresh and 11 done)

	Pruned	Kept	Total
New	164	0	164
Fresh	0	0	0
Picked	0	1	1
Done	0	10	10
Total	164	11	175

Accuracy

99.6%

Counts

175 → 11

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	50.3%	(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
✓	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
✓	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
✓	9.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.4%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	50.3%	(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
✓	9.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 218 to 169 computations (22.5% saved)

regimes42.0ms (1.6%)

Memory

-39.6MiB live, 61.4MiB allocated; 9ms collecting garbage

Counts

12 → 1

Calls

Call 1

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

Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))

Calls

8 calls:

15.0ms	re
4.0ms	im
3.0ms	(+.f64 (.f64 re re) (.f64 im im))
3.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
3.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Results

Accuracy	Segments	Branch
99.0%	1	`(*.f64 im im)`
99.0%	1	`(*.f64 re re)`
99.0%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.0%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.0%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
99.0%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
99.0%	1	`re`
99.0%	1	`im`

Compiler

Compiled 34 to 38 computations (-11.8% saved)

regimes28.0ms (1%)

Memory

16.2MiB live, 61.1MiB allocated; 3ms collecting garbage

Accuracy

Total -63.0b remaining (-6054.3%)

Threshold costs -63b (-6054.3%)

Counts

11 → 1

Calls

Call 1

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

Outputs
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))

Calls

8 calls:

5.0ms	(*.f64 re re)
3.0ms	im
3.0ms	re
3.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
3.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Results

Accuracy	Segments	Branch
98.4%	1	`(*.f64 im im)`
98.4%	1	`(*.f64 re re)`
98.4%	1	`(+.f64 (.f64 re re) (.f64 im im))`
98.4%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
98.4%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
98.4%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
98.4%	1	`re`
98.4%	1	`im`

Compiler

Compiled 34 to 38 computations (-11.8% saved)

derivations55.0ms (2.1%)

Memory

31.3MiB live, 77.3MiB allocated; 4ms collecting garbage

Stop Event

1×

done

Compiler

Compiled 14 to 14 computations (0% saved)

preprocess31.0ms (1.1%)

Memory: -38.1MiB live, 56.6MiB allocated; 17ms collecting garbage
Compiler: Compiled 132 to 132 computations (0% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze98.0ms (3.7%)

sample847.0ms (31.7%)

preprocess165.0ms (6.2%)

series15.0ms (0.6%)

rewrite227.0ms (8.5%)

eval23.0ms (0.8%)

prune6.0ms (0.2%)

series74.0ms (2.8%)

rewrite580.0ms (21.7%)

eval14.0ms (0.5%)

prune9.0ms (0.3%)

series23.0ms (0.8%)

rewrite189.0ms (7.1%)

eval23.0ms (0.9%)

prune6.0ms (0.2%)

series7.0ms (0.3%)

rewrite156.0ms (5.8%)

eval49.0ms (1.8%)

prune8.0ms (0.3%)

regimes42.0ms (1.6%)

regimes28.0ms (1%)

derivations55.0ms (2.1%)

preprocess31.0ms (1.1%)

end0.0ms (0%)

Profiling