Metrics for math.log/2 on complex, imaginary part

start0.0ms (0%)

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

analyze264.0ms (4.3%)

Memory

-11.4MiB live, 354.0MiB allocated; 127ms 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%	49.9%	0.1%	0%	49.9%	0%	4
0%	0%	49.9%	0.1%	0%	49.9%	0%	5
0%	0%	49.9%	0.1%	0%	49.9%	0%	6
9.4%	4.7%	45.2%	0.1%	0%	49.9%	0%	7
17.2%	8.6%	41.3%	0.1%	0%	49.9%	0%	8
27.3%	13.7%	36.3%	0.1%	0%	49.9%	0%	9
41%	20.5%	29.4%	0.1%	0%	49.9%	0%	10
48.6%	24.3%	25.6%	0.1%	0%	49.9%	0%	11
57.1%	28.5%	21.4%	0.1%	0%	49.9%	0%	12

Compiler

Compiled 30 to 17 computations (43.3% saved)

sample2.1s (33.5%)

Memory

31.0MiB live, 2 703.0MiB allocated; 491ms collecting garbage

Samples

1.4s

8 256×

valid

Precisions

Click to see histograms. Total time spent on operations: 1.0s

ival-mult: 280.0ms (27.7% of total)

ival-hypot: 255.0ms (25.3% of total)

ival-log: 174.0ms (17.2% of total)

ival-atan2: 120.0ms (11.9% of total)

ival-div: 73.0ms (7.2% of total)

ival-add: 52.0ms (5.2% of total)

ival-sub: 44.0ms (4.4% of total)

exact: 6.0ms (0.6% of total)

adjust: 3.0ms (0.3% of total)

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

Bogosity

explain423.0ms (6.8%)

Memory

24.3MiB live, 454.7MiB allocated; 69ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
120	-	0	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
1	-	1	(3.911586098422337e+287 1.1905033332144435e-36 1.381042639769139e-224)	`(*.f64 (atan2.f64 im re) (log.f64 base))`
0	-	0	-	`(log.f64 base)`
0	-	0	-	`(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`(atan2.f64 im re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))`
0	-	0	-	`(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))`
0	-	0	-	`(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))`
0	-	0	-	`#s(literal 0 binary64)`
0	-	0	-	`(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))`
0	-	0	-	`(*.f64 (log.f64 base) (log.f64 base))`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`base`
0	-	0	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	102	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	102
↳	`(*.f64 re re)`	overflow	59
↳	`(*.f64 im im)`	overflow	56

Confusion

	Predicted +	Predicted -
+	102	18
-	0	136

Precision

1.0

Recall

0.85

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	102	0	18
-	0	0	136

Precision?

1.0

Recall?

0.85

Freqs

test

number	freq
0	154
1	102

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

125.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

ival-mult: 38.0ms (37.3% of total)

ival-log: 17.0ms (16.7% of total)

ival-add: 15.0ms (14.7% of total)

ival-atan2: 15.0ms (14.7% of total)

ival-hypot: 9.0ms (8.8% of total)

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

ival-sub: 3.0ms (2.9% of total)

ival-true: 1.0ms (1% of total)

adjust: 0.0ms (0% of total)

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

exact: 0.0ms (0% of total)

preprocess230.0ms (3.7%)

Memory

-1.4MiB live, 239.4MiB allocated; 60ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	79	153
1	229	133
2	964	86
3	6091	86
0	18	26
0	34	14
1	63	12
2	180	8
3	921	6
4	2477	6
5	5141	6
0	8291	6

Stop Event

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

Calls

Call 1

Inputs

(/.f64 (-.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Outputs

(/.f64 (-.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

(/.f64 (atan2.f64 im re) (log.f64 base))

Compiler

Compiled 28 to 18 computations (35.7% saved)

eval0.0ms (0%)

Memory: 0.2MiB live, 0.2MiB allocated; 0ms collecting garbage
Compiler: Compiled 0 to 3 computations (-∞% saved)

prune1.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	52.7%	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Status

Accuracy

Program

▶

52.7%

(/.f64 (-.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Compiler

Compiled 28 to 18 computations (35.7% saved)

simplify149.0ms (2.4%)

Memory

-15.8MiB live, 174.6MiB allocated; 17ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	2	(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
cost-diff	4	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	5	(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))
cost-diff	5	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	113
0	34	77
1	63	75
2	180	71
3	921	69
4	2477	69
5	5141	67
0	8291	56

Stop Event

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

Calls

Call 1

Inputs
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(log.f64 base)
base
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 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)
(*.f64 im im)
#s(literal 0 binary64)
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))

Outputs
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (atan2.f64 im re) (log.f64 base))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(*.f64 (log.f64 base) (atan2.f64 im re))
(atan2.f64 im re)
im
re
(log.f64 base)
base
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))
#s(literal 0 binary64)
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (hypot.f64 re im))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 re im)
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
(*.f64 im im)
#s(literal 0 binary64)
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
#s(literal 0 binary64)

localize63.0ms (1%)

Memory

10.0MiB live, 196.2MiB allocated; 26ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.340680934065628	(*.f64 (atan2.f64 im re) (log.f64 base))
accuracy	0.34765625	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
accuracy	0.5543937988422102	(*.f64 (log.f64 base) (log.f64 base))
accuracy	27.923987646062574	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

47.0ms

256×

valid

Compiler

Compiled 121 to 20 computations (83.5% saved)

Precisions

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

ival-log: 10.0ms (30% of total)

ival-mult: 8.0ms (24% of total)

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

ival-add: 3.0ms (9% of total)

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

ival-atan2: 2.0ms (6% of total)

ival-sub: 1.0ms (3% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series227.0ms (3.7%)

Memory

-11.5MiB live, 375.3MiB allocated; 52ms collecting garbage

Counts

6 → 35

Calls

Call 1

Inputs
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 (atan2.f64 im re) (log.f64 base))

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

Calls

9 calls:

Time	Variable		Point	Expression
90.0ms	re	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (log (sqrt (+ (* re re) (* im im)))) 0) (sqrt (+ (* re re) (* im im))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (log base)) (* (atan2 im re) (log base)))
58.0ms	base	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (log (sqrt (+ (* re re) (* im im)))) 0) (sqrt (+ (* re re) (* im im))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (log base)) (* (atan2 im re) (log base)))
20.0ms	base	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (log (sqrt (+ (* re re) (* im im)))) 0) (sqrt (+ (* re re) (* im im))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (log base)) (* (atan2 im re) (log base)))
15.0ms	im	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (log (sqrt (+ (* re re) (* im im)))) 0) (sqrt (+ (* re re) (* im im))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (log base)) (* (atan2 im re) (log base)))
11.0ms	re	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (* (log (sqrt (+ (* re re) (* im im)))) 0) (sqrt (+ (* re re) (* im im))) (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (* (log base) (log base)) (* (atan2 im re) (log base)))

simplify185.0ms (3%)

Memory

12.7MiB live, 246.9MiB allocated; 19ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	168	804
1	420	782
2	1813	761
0	8390	617

Stop Event

1×	iter limit
1×	node limit

Counts

35 → 35

Calls

Call 1

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

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

rewrite60.0ms (1%)

Memory

28.6MiB live, 74.7MiB allocated; 5ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	74
0	34	38
1	120	36
0	965	31

Stop Event

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

Counts

6 → 217

Calls

Call 1

Inputs
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) #s(literal 0 binary64))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 (atan2.f64 im re) (log.f64 base))

Outputs
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))))
(*.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (log.f64 base) (neg.f64 (log.f64 base))))
(*.f64 (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))))
(*.f64 (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))))
(*.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (atan2.f64 im re) (log.f64 base)))
(*.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (neg.f64 (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (fabs.f64 (log.f64 base))) (fabs.f64 (log.f64 base)))
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (+.f64 #s(literal 0 binary64) (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (log.f64 base) (atan2.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(neg.f64 (/.f64 (neg.f64 (*.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(neg.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (atan2.f64 im re) (neg.f64 (log.f64 base))) (/.f64 (log.f64 base) (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (atan2.f64 im re) (fabs.f64 (log.f64 base))) (/.f64 (log.f64 base) (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (atan2.f64 im re) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(-.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(+.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
#s(literal 0 binary64)
(.f64 (pow.f64 (fma.f64 re re (.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (fabs.f64 re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (fabs.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (fabs.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im re)
(exp.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (neg.f64 (.f64 (log.f64 base) (atan2.f64 im re))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)))
(fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))
(fma.f64 (atan2.f64 im re) (log.f64 base) #s(literal 0 binary64))
(-.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (neg.f64 (log.f64 (hypot.f64 re im)))) #s(literal 0 binary64)))
(-.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 #s(literal 0 binary64) (.f64 (log.f64 base) (atan2.f64 im re))))
(-.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 #s(literal 0 binary64) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (atan2.f64 im re)))
(+.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(*.f64 (+.f64 (neg.f64 (log.f64 base)) #s(literal 0 binary64)) (-.f64 (neg.f64 (log.f64 base)) #s(literal 0 binary64)))
(*.f64 (+.f64 (fabs.f64 (log.f64 base)) #s(literal 0 binary64)) (-.f64 (fabs.f64 (log.f64 base)) #s(literal 0 binary64)))
(*.f64 (+.f64 (log.f64 base) #s(literal 0 binary64)) (-.f64 (log.f64 base) #s(literal 0 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fma.f64 (+.f64 (neg.f64 (log.f64 base)) #s(literal 0 binary64)) (-.f64 (neg.f64 (log.f64 base)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (+.f64 (neg.f64 (log.f64 base)) #s(literal 0 binary64)) (-.f64 (neg.f64 (log.f64 base)) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (+.f64 (fabs.f64 (log.f64 base)) #s(literal 0 binary64)) (-.f64 (fabs.f64 (log.f64 base)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (+.f64 (fabs.f64 (log.f64 base)) #s(literal 0 binary64)) (-.f64 (fabs.f64 (log.f64 base)) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (+.f64 (log.f64 base) #s(literal 0 binary64)) (-.f64 (log.f64 base) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (+.f64 (log.f64 base) #s(literal 0 binary64)) (-.f64 (log.f64 base) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (neg.f64 (.f64 (log.f64 base) (atan2.f64 im re))))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)))
(fma.f64 (log.f64 base) (atan2.f64 im re) #s(literal 0 binary64))
(fma.f64 (atan2.f64 im re) (log.f64 base) #s(literal 0 binary64))
(-.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (neg.f64 (neg.f64 (log.f64 (hypot.f64 re im)))) #s(literal 0 binary64)))
(-.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 #s(literal 0 binary64) (.f64 (log.f64 base) (atan2.f64 im re))))
(-.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 #s(literal 0 binary64) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))))
(-.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (atan2.f64 im re)))
(+.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 0 binary64))
(log.f64 (pow.f64 base (atan2.f64 im re)))

eval34.0ms (0.6%)

Memory: -15.3MiB live, 88.2MiB allocated; 6ms collecting garbage
Compiler: Compiled 6 417 to 1 060 computations (83.5% saved)

prune12.0ms (0.2%)

Memory

-11.1MiB live, 35.2MiB allocated; 3ms collecting garbage

Pruning

12 alts after pruning (12 fresh and 0 done)

	Pruned	Kept	Total
New	219	12	231
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	220	12	232

Accuracy

100.0%

Counts

232 → 12

Alt Table

Click to see full alt table

Status	Accuracy	Program
	83.3%	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	87.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	83.3%	(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.5%	(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
	86.3%	(/.f64 (-.f64 (.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.3%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.3%	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.3%	(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.7%	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.0%	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	99.2%	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Compiler

Compiled 472 to 296 computations (37.3% saved)

simplify128.0ms (2.1%)

Memory

-5.5MiB live, 135.0MiB allocated; 21ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 (log.f64 base) (atan2.f64 im re))
cost-diff	0	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	2	(-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
cost-diff	3	(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(log.f64 base)
cost-diff	0	(*.f64 (log.f64 base) (atan2.f64 im re))
cost-diff	0	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	3	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(atan2.f64 im re)
cost-diff	0	(log.f64 base)
cost-diff	0	(*.f64 (log.f64 base) (atan2.f64 im re))
cost-diff	5	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(atan2.f64 im re)
cost-diff	0	(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(log.f64 base)
cost-diff	5	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	0	(log.f64 base)
cost-diff	0	(atan2.f64 im re)
cost-diff	0	(/.f64 (atan2.f64 im re) (log.f64 base))
cost-diff	0	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	35	227
0	49	200
1	92	198
2	284	183
3	1755	181
4	5200	181
0	8106	181

Stop Event

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

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(log.f64 base)
base
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(log.f64 base)
base
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 0 binary64)
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(log.f64 base)
base
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 base)
base
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 0 binary64)
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)

localize179.0ms (2.9%)

Memory

-10.6MiB live, 181.7MiB allocated; 49ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.340680934065628	(*.f64 (log.f64 base) (atan2.f64 im re))
accuracy	0.4850652048587383	(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.899483105643406	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.340680934065628	(*.f64 (log.f64 base) (atan2.f64 im re))
accuracy	0.434885915474395	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.899483105643406	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.0	(log.f64 base)
accuracy	0.340680934065628	(*.f64 (log.f64 base) (atan2.f64 im re))
accuracy	0.34765625	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.0	(log.f64 base)
accuracy	0.34375	(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.3699775215533833	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.0	(atan2.f64 im re)
accuracy	0.0	(log.f64 base)
accuracy	0.0	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
accuracy	0.29296875	(/.f64 (atan2.f64 im re) (log.f64 base))

Samples

137.0ms

256×

valid

Compiler

Compiled 224 to 31 computations (86.2% saved)

Precisions

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

ival-div: 59.0ms (63.8% of total)

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

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

ival-log: 5.0ms (5.4% of total)

ival-pow: 4.0ms (4.3% of total)

ival-sub: 3.0ms (3.2% of total)

ival-atan2: 2.0ms (2.2% of total)

ival-pow2: 2.0ms (2.2% of total)

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

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series177.0ms (2.9%)

Memory

24.4MiB live, 262.2MiB allocated; 25ms collecting garbage

Counts

15 → 43

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
(log.f64 base)
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 2))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (log (/ 1 base)) 2))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))

Calls

9 calls:

Time	Variable		Point	Expression
51.0ms	re	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) (log base) (* (log base) (/ (atan2 im re) (pow (log base) 2))) (/ (atan2 im re) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (* (log base) (atan2 im re)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (pow (log base) 2) (pow (log base) 4))
41.0ms	base	@	0	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) (log base) (* (log base) (/ (atan2 im re) (pow (log base) 2))) (/ (atan2 im re) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (* (log base) (atan2 im re)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (pow (log base) 2) (pow (log base) 4))
28.0ms	im	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) (log base) (* (log base) (/ (atan2 im re) (pow (log base) 2))) (/ (atan2 im re) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (* (log base) (atan2 im re)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (pow (log base) 2) (pow (log base) 4))
11.0ms	base	@	inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) (log base) (* (log base) (/ (atan2 im re) (pow (log base) 2))) (/ (atan2 im re) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (* (log base) (atan2 im re)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (pow (log base) 2) (pow (log base) 4))
10.0ms	re	@	-inf	((/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (atan2 im re) (log base)) (atan2 im re) (log base) (* (log base) (/ (atan2 im re) (pow (log base) 2))) (/ (atan2 im re) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (* (log base) (atan2 im re)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (pow (log base) 2) (pow (log base) 4))

simplify110.0ms (1.8%)

Memory

4.6MiB live, 146.6MiB allocated; 14ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	109	809
1	194	735
2	542	675
3	4352	675
0	8751	675

Stop Event

1×	iter limit
1×	node limit

Counts

43 → 43

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 2))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (log (/ 1 base)) 2))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (atan2 im re) (atan2.f64 im re))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 2))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (log base) (log.f64 base))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (log base) (log.f64 base))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (log (/ 1 base)) 2))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (log.f64 base) (atan2.f64 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64)))
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (/ (atan2 im re) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (log base) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2))))
#s(approx (/ (atan2 im re) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 2 binary64))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) (atan2.f64 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (log base) 2) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 2 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 4 binary64)))

rewrite28.0ms (0.4%)

Memory

-0.6MiB live, 45.9MiB allocated; 2ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	35	157
0	49	140
0	180	140

Stop Event

1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit

Counts

15 → 61

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
(log.f64 base)
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (log.f64 base)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
(log.f64 base)
(*.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (log.f64 base))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (log.f64 base))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (neg.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))
(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (fma.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)))))
(-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))
(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (fma.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)))))
(-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (neg.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))

eval20.0ms (0.3%)

Memory: -8.2MiB live, 38.6MiB allocated; 3ms collecting garbage
Compiler: Compiled 3 423 to 377 computations (89% saved)

prune18.0ms (0.3%)

Memory

-6.8MiB live, 46.9MiB allocated; 2ms collecting garbage

Pruning

16 alts after pruning (13 fresh and 3 done)

	Pruned	Kept	Total
New	163	8	171
Fresh	2	5	7
Picked	2	3	5
Done	0	0	0
Total	167	16	183

Accuracy

100.0%

Counts

183 → 16

Alt Table

Click to see full alt table

Status	Accuracy	Program
	87.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	83.3%	(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	99.5%	(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
	87.1%	(/.f64 (-.f64 (/.f64 (-.f64 (.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (fma.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	43.0%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
▶	99.2%	(/.f64 (-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.2%	(/.f64 (-.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.3%	(/.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
✓	99.3%	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	99.3%	(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.7%	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	98.9%	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	98.9%	(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.2%	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.1%	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Compiler

Compiled 609 to 398 computations (34.6% saved)

simplify120.0ms (1.9%)

Memory

-7.3MiB live, 191.3MiB allocated; 46ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 (log.f64 base) (atan2.f64 im re))
cost-diff	3	(/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	5	(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	7	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(log.f64 base)
cost-diff	2	(-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64))
cost-diff	3	(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	7	(/.f64 (-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	0	(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	0	(log.f64 base)
cost-diff	3	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
cost-diff	7	(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(log.f64 base)
cost-diff	0	(atan2.f64 im re)
cost-diff	2	(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	3	(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(log.f64 base)
cost-diff	0	(*.f64 (log.f64 base) (atan2.f64 im re))
cost-diff	0	(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
cost-diff	6	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base))

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	25	253
0	44	212
1	75	212
2	179	186
3	899	172
4	4926	172
0	8140	172

Stop Event

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

Calls

Call 1

Inputs
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(atan2.f64 im re)
im
re
(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(log.f64 base)
base
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(log.f64 base)
base
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64))
(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(log.f64 base)
base
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 0 binary64)
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)

Outputs
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
(/.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base))
(atan2.f64 im re)
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (atan2.f64 im re) (log.f64 base))
(atan2.f64 im re)
im
re
(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(log.f64 base)
base
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(log.f64 base)
base
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(log.f64 base)
base
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 0 binary64)
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (atan2.f64 im re) (log.f64 base))
(/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)

localize189.0ms (3.1%)

Memory

-7.7MiB live, 177.9MiB allocated; 62ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.340680934065628	(*.f64 (log.f64 base) (atan2.f64 im re))
accuracy	0.434885915474395	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.46322250976844204	(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.3937830465038732	(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.4148854349366626	(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.899483105643406	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.41334973955499277	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
accuracy	0.434885915474395	(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.899483105643406	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.0	(log.f64 base)
accuracy	0.32259750976844204	(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.33984375	(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.0	(log.f64 base)
accuracy	0.29296875	(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
accuracy	0.33984375	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base))
accuracy	0.340680934065628	(*.f64 (log.f64 base) (atan2.f64 im re))

Samples

119.0ms

256×

valid

Compiler

Compiled 255 to 27 computations (89.4% saved)

Precisions

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

ival-atan2: 56.0ms (64% of total)

ival-mult: 11.0ms (12.6% of total)

ival-div: 8.0ms (9.1% of total)

ival-pow: 4.0ms (4.6% of total)

ival-log: 3.0ms (3.4% of total)

ival-pow2: 3.0ms (3.4% of total)

ival-sub: 1.0ms (1.1% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series101.0ms (1.6%)

Memory

38.5MiB live, 180.3MiB allocated; 12ms collecting garbage

Counts

19 → 53

Calls

Call 1

Inputs
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base))
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(atan2.f64 im re)
(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))

Outputs
#s(approx (/ (* (log base) (atan2 im re)) (log base)) #s(hole binary64 (atan2 im re)))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 4))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 2) (atan2 im re))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (log base))))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log (/ 1 base)) 4))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (atan2 im re))))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (atan2 im re))))

Calls

9 calls:

Time	Variable		Point	Expression
24.0ms	re	@	-inf	((/ (* (log base) (atan2 im re)) (log base)) (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) (* (log base) (atan2 im re)) (log base) (/ (log base) (pow (log base) 2)) (* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/ (atan2 im re) (pow (log base) 4)) (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) (* (log base) (* (atan2 im re) (pow (log base) 2))) (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) (* (pow (log base) 2) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2) (pow (log base) 4) (* (atan2 im re) (pow (log base) 2)))
11.0ms	base	@	inf	((/ (* (log base) (atan2 im re)) (log base)) (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) (* (log base) (atan2 im re)) (log base) (/ (log base) (pow (log base) 2)) (* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/ (atan2 im re) (pow (log base) 4)) (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) (* (log base) (* (atan2 im re) (pow (log base) 2))) (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) (* (pow (log base) 2) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2) (pow (log base) 4) (* (atan2 im re) (pow (log base) 2)))
11.0ms	im	@	-inf	((/ (* (log base) (atan2 im re)) (log base)) (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) (* (log base) (atan2 im re)) (log base) (/ (log base) (pow (log base) 2)) (* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/ (atan2 im re) (pow (log base) 4)) (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) (* (log base) (* (atan2 im re) (pow (log base) 2))) (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) (* (pow (log base) 2) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2) (pow (log base) 4) (* (atan2 im re) (pow (log base) 2)))
10.0ms	base	@	-inf	((/ (* (log base) (atan2 im re)) (log base)) (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) (* (log base) (atan2 im re)) (log base) (/ (log base) (pow (log base) 2)) (* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/ (atan2 im re) (pow (log base) 4)) (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) (* (log base) (* (atan2 im re) (pow (log base) 2))) (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) (* (pow (log base) 2) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2) (pow (log base) 4) (* (atan2 im re) (pow (log base) 2)))
9.0ms	re	@	0	((/ (* (log base) (atan2 im re)) (log base)) (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) (* (log base) (atan2 im re)) (log base) (/ (log base) (pow (log base) 2)) (* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/ (atan2 im re) (pow (log base) 4)) (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) (* (log base) (* (atan2 im re) (pow (log base) 2))) (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) (* (pow (log base) 2) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2) (pow (log base) 4) (* (atan2 im re) (pow (log base) 2)))

simplify131.0ms (2.1%)

Memory

18.0MiB live, 150.2MiB allocated; 25ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	119	911
1	187	876
2	399	766
3	2153	762
4	6450	762
0	8276	762

Stop Event

1×	iter limit
1×	node limit

Counts

53 → 53

Calls

Call 1

Inputs
#s(approx (/ (* (log base) (atan2 im re)) (log base)) #s(hole binary64 (atan2 im re)))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 4))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 2) (atan2 im re))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (log base))))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log (/ 1 base)) 4))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (atan2 im re))))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (atan2 im re))))

Outputs
#s(approx (/ (* (log base) (atan2 im re)) (log base)) #s(hole binary64 (atan2 im re)))
#s(approx (/ (* (log base) (atan2 im re)) (log base)) (atan2.f64 im re))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (/ (* (log base) (atan2 im re)) (log base)) (atan2.f64 im re))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 4))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 2) (atan2 im re))))
#s(approx (* (atan2 im re) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (log base) (log.f64 base))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (log base))))
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (log base) (log.f64 base))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log (/ 1 base)) 4))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (atan2 im re))))
#s(approx (* (atan2 im re) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
#s(approx (/ (/ (* (log base) (atan2 im re)) (log base)) (log base)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) (atan2.f64 im re)))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (log base) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal -1 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) (log.f64 #s(literal -1 binary64)))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4))))
#s(approx (/ (atan2 im re) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 4 binary64))))
#s(approx (/ (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (- (* (log base) (* (atan2 im re) (pow (log base) 2))) 0) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (* (log base) (* (atan2 im re) (pow (log base) 2))) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (/ (atan2 im re) (pow (log base) 4))) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (pow (log base) 2) (pow (log base) 2)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 4 binary64)))
#s(approx (/ (* (log base) (atan2 im re)) (* (pow (log base) 2) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (* (log base) (/ (atan2 im re) (pow (log base) 4))) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (log base) 2) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 2 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 4 binary64)))
#s(approx (* (atan2 im re) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (atan2 im re))))
#s(approx (* (atan2 im re) (pow (log base) 2)) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 2 binary64)) (atan2.f64 im re)))

rewrite23.0ms (0.4%)

Memory

-18.0MiB live, 29.5MiB allocated; 2ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	25	189
0	44	169
0	114	169

Stop Event

1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit

Counts

19 → 81

Calls

Call 1

Inputs
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base))
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(atan2.f64 im re)
(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))

Outputs
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (log.f64 base)))
(/.f64 (neg.f64 (*.f64 (atan2.f64 im re) (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (log.f64 base))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (log.f64 base)) (log.f64 base))
(/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (atan2.f64 im re) (log.f64 base))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
(/.f64 (neg.f64 (log.f64 base)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (log.f64 base)) (log.f64 base))
(/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(atan2.f64 im re)
(.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)))
(.f64 (log.f64 base) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(*.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 (atan2.f64 im re) (log.f64 base))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)))
(.f64 (log.f64 base) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))) #s(literal 0 binary64)) (fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) #s(literal 0 binary64)))))
(-.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) #s(literal 0 binary64))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))) #s(literal 0 binary64)) (fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base) #s(literal 0 binary64)))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) #s(literal 0 binary64)))))
(-.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) #s(literal 0 binary64))
(.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)))
(.f64 (log.f64 base) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(-.f64 (.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(*.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 (atan2.f64 im re) (log.f64 base))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))

eval30.0ms (0.5%)

Memory: -19.2MiB live, 30.5MiB allocated; 19ms collecting garbage
Compiler: Compiled 3 013 to 344 computations (88.6% saved)

prune10.0ms (0.2%)

Memory

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

Pruning

16 alts after pruning (11 fresh and 5 done)

	Pruned	Kept	Total
New	143	4	147
Fresh	1	7	8
Picked	3	2	5
Done	0	3	3
Total	147	16	163

Accuracy

100.0%

Counts

163 → 16

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	87.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	83.3%	(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
✓	99.5%	(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
	87.1%	(/.f64 (-.f64 (/.f64 (-.f64 (.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))) #s(literal 0 binary64)) (fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base) #s(literal 0 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	43.0%	(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
	99.2%	(/.f64 (-.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.2%	(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.3%	(/.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
✓	99.3%	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.3%	(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.4%	(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	98.9%	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	98.7%	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
✓	99.2%	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.1%	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Compiler

Compiled 576 to 379 computations (34.2% saved)

simplify457.0ms (7.4%)

Memory

37.1MiB live, 485.4MiB allocated; 188ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 (log.f64 base) (atan2.f64 im re))
cost-diff	0	(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))
cost-diff	3	(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	11	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
cost-diff	0	(pow.f64 (log.f64 base) #s(literal 2 binary64))
cost-diff	0	(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
cost-diff	0	(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	3	(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
cost-diff	0	(log.f64 base)
cost-diff	0	(*.f64 (log.f64 base) (atan2.f64 im re))
cost-diff	0	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
cost-diff	3	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
cost-diff	0	(atan2.f64 im re)
cost-diff	0	(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
cost-diff	0	#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
cost-diff	0	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
cost-diff	0	(/.f64 #s(literal 1 binary64) (log.f64 base))
cost-diff	0	#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
cost-diff	0	(atan2.f64 im re)
cost-diff	0	(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	36	274
0	57	274
1	85	262
2	178	246
3	773	242
4	3657	242
0	8195	242

Stop Event

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

Calls

Call 1

Inputs
(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(atan2.f64 im re)
im
re
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
#s(literal 1 binary64)
(log.f64 base)
base
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 3 binary64))
(log.f64 base)
base
#s(literal 3 binary64)
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 6 binary64))
#s(literal 6 binary64)
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(log.f64 base)
base
#s(literal 2 binary64)
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
#s(literal 2 binary64)
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))

Outputs
(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(*.f64 #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (atan2.f64 im re))
(atan2.f64 im re)
im
re
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
#s(literal 1 binary64)
(log.f64 base)
base
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 3 binary64))
(log.f64 base)
base
#s(literal 3 binary64)
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (atan2.f64 im re))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 6 binary64))
#s(literal 6 binary64)
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(log.f64 base)
base
#s(literal 2 binary64)
(atan2.f64 im re)
im
re
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (atan2.f64 im re) (log.f64 base))
(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
base
(atan2.f64 im re)
im
re
#s(literal 2 binary64)
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 2 binary64))

localize120.0ms (1.9%)

Memory

-14.4MiB live, 275.2MiB allocated; 48ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.42710878907376815	(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))
accuracy	0.4850652048587383	(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	7.812166126456762	(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
accuracy	0.3937830465038732	(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
accuracy	0.4148854349366626	(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.899483105643406	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	0.36328125	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
accuracy	0.6369031556107364	(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
accuracy	0.899483105643406	(pow.f64 (log.f64 base) #s(literal 4 binary64))
accuracy	1.2086724713420551	(pow.f64 (log.f64 base) #s(literal 6 binary64))
accuracy	0.28125	(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
accuracy	0.434885915474395	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
accuracy	0.5543937988422102	(pow.f64 (log.f64 base) #s(literal 2 binary64))
accuracy	0.7029840332848188	(pow.f64 (log.f64 base) #s(literal 3 binary64))
accuracy	0.0	(log.f64 base)
accuracy	0.0	#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
accuracy	0.2109375	(/.f64 #s(literal 1 binary64) (log.f64 base))
accuracy	0.33984375	(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))

Samples

89.0ms

256×

valid

Compiler

Compiled 248 to 31 computations (87.5% saved)

Precisions

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

ival-pow: 11.0ms (25.3% of total)

ival-div: 10.0ms (23% of total)

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

ival-pow2: 5.0ms (11.5% of total)

ival-log: 3.0ms (6.9% of total)

ival-atan2: 2.0ms (4.6% of total)

exact: 1.0ms (2.3% of total)

adjust: 0.0ms (0% of total)

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

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

series221.0ms (3.6%)

Memory

-23.5MiB live, 268.1MiB allocated; 89ms collecting garbage

Counts

21 → 61

Calls

Call 1

Inputs
(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(atan2.f64 im re)
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 3 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))

Outputs
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 5))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (log base) 2) (atan2 im re))))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (log base) 2) (pow (atan2 im re) 2))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (log base))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (log base) 3)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log base) 6)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 5)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (atan2 im re))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (pow (atan2 im re) 2))))
#s(approx (pow (log base) 3) #s(hole binary64 (* -1 (pow (log (/ 1 base)) 3))))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 5))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (atan2 im re))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (pow (atan2 im re) 2))))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))

Calls

9 calls:

Time	Variable		Point	Expression
132.0ms	base	@	inf	((* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (/ (log base) (pow (log base) 2)) (/ 1 (log base)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/ (atan2 im re) (pow (log base) 3)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (* (log base) (atan2 im re)) (log base) (* (* (pow (log base) 2) (atan2 im re)) (log base)) (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) (* (pow (log base) 2) (atan2 im re)) (pow (log base) 2) (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (pow (* (log base) (atan2 im re)) 2) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4))
16.0ms	re	@	0	((* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (/ (log base) (pow (log base) 2)) (/ 1 (log base)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/ (atan2 im re) (pow (log base) 3)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (* (log base) (atan2 im re)) (log base) (* (* (pow (log base) 2) (atan2 im re)) (log base)) (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) (* (pow (log base) 2) (atan2 im re)) (pow (log base) 2) (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (pow (* (log base) (atan2 im re)) 2) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4))
13.0ms	base	@	-inf	((* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (/ (log base) (pow (log base) 2)) (/ 1 (log base)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/ (atan2 im re) (pow (log base) 3)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (* (log base) (atan2 im re)) (log base) (* (* (pow (log base) 2) (atan2 im re)) (log base)) (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) (* (pow (log base) 2) (atan2 im re)) (pow (log base) 2) (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (pow (* (log base) (atan2 im re)) 2) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4))
11.0ms	im	@	-inf	((* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (/ (log base) (pow (log base) 2)) (/ 1 (log base)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/ (atan2 im re) (pow (log base) 3)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (* (log base) (atan2 im re)) (log base) (* (* (pow (log base) 2) (atan2 im re)) (log base)) (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) (* (pow (log base) 2) (atan2 im re)) (pow (log base) 2) (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (pow (* (log base) (atan2 im re)) 2) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4))
10.0ms	base	@	0	((* (atan2 im re) (/ (log base) (pow (log base) 2))) (atan2 im re) (/ (log base) (pow (log base) 2)) (/ 1 (log base)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/ (atan2 im re) (pow (log base) 3)) (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (* (log base) (atan2 im re)) (log base) (* (* (pow (log base) 2) (atan2 im re)) (log base)) (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) (* (pow (log base) 2) (atan2 im re)) (pow (log base) 2) (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) (* (* (log base) (atan2 im re)) (pow (log base) 2)) (pow (* (log base) (atan2 im re)) 2) (pow (log base) 3) (pow (log base) 6) (pow (log base) 4))

simplify122.0ms (2%)

Memory

26.1MiB live, 210.5MiB allocated; 17ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	138	1079
1	211	1019
2	448	962
3	2664	962
0	8767	962

Stop Event

1×	iter limit
1×	node limit

Counts

61 → 61

Calls

Call 1

Inputs
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 5))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (log base) 2) (atan2 im re))))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (log base) 2) (pow (atan2 im re) 2))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (log base))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (log base))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (log base) 3)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log base) 6)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 5)))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (atan2 im re))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (pow (atan2 im re) 2))))
#s(approx (pow (log base) 3) #s(hole binary64 (* -1 (pow (log (/ 1 base)) 3))))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 5))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (atan2 im re))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (pow (atan2 im re) 2))))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))

Outputs
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (atan2 im re) (atan2.f64 im re))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (/ (atan2 im re) (pow (log base) 5))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 5 binary64))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (log base) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (log base) 2) (atan2 im re))))
#s(approx (* (pow (log base) 2) (atan2 im re)) (*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (log base))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (log base) 3) (atan2 im re))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (log base) 2) (pow (atan2 im re) 2))))
#s(approx (pow (* (log base) (atan2 im re)) 2) (pow.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) #s(literal 2 binary64)))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (log base))))
#s(approx (/ 1 (log base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (log base))))
#s(approx (/ 1 (log base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx (log base) (log.f64 base))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log base) 2)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (log base) 3)))
#s(approx (pow (log base) 3) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log base) 6)))
#s(approx (pow (log base) 6) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (/ 1 (log base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ -1 (log (/ 1 base)))))
#s(approx (/ 1 (log base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 3)))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (* -1 (/ (atan2 im re) (pow (log (/ 1 base)) 5)))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (/.f64 (neg.f64 (atan2.f64 im re)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 5 binary64))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* -1 (* (log (/ 1 base)) (atan2 im re)))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (log base) (log.f64 base))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (atan2 im re))))
#s(approx (* (pow (log base) 2) (atan2 im re)) (*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (pow (log base) 2) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (* -1 (/ (atan2 im re) (log (/ 1 base))))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) (/.f64 (atan2.f64 im re) (log.f64 base)))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* -1 (* (pow (log (/ 1 base)) 3) (atan2 im re)))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (log (/ 1 base)) 2) (pow (atan2 im re) 2))))
#s(approx (pow (* (log base) (atan2 im re)) 2) (pow.f64 (*.f64 (atan2.f64 im re) (log.f64 base)) #s(literal 2 binary64)))
#s(approx (pow (log base) 3) #s(hole binary64 (* -1 (pow (log (/ 1 base)) 3))))
#s(approx (pow (log base) 3) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (log (/ 1 base)) 6)))
#s(approx (pow (log base) 6) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 6 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (pow (log base) 4) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64)))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (/ (log base) (pow (log base) 2)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (log base)) (/.f64 #s(literal -1 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) (log.f64 #s(literal -1 binary64)))))
#s(approx (/ 1 (log base)) #s(hole binary64 (/ 1 (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ 1 (log base)) (/.f64 #s(literal -1 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) base)) (log.f64 #s(literal -1 binary64)))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3))))
#s(approx (/ (atan2 im re) (pow (log base) 3)) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) #s(hole binary64 (/ (atan2 im re) (pow (+ (log -1) (* -1 (log (/ -1 base)))) 5))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 6)) (/.f64 (atan2.f64 im re) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 5 binary64))))
#s(approx (* (log base) (atan2 im re)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 base)))) (atan2 im re))))
#s(approx (* (log base) (atan2 im re)) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) (atan2.f64 im re)))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (log base) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))))
#s(approx (* (* (pow (log base) 2) (atan2 im re)) (log base)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (/ (* (* (pow (log base) 2) (atan2 im re)) (log base)) (pow (log base) 4)) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (pow (log base) 2)) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (pow (log base) 2) (atan2 im re)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (atan2 im re))))
#s(approx (* (pow (log base) 2) (atan2 im re)) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 2 binary64)) (atan2.f64 im re)))
#s(approx (pow (log base) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (pow (log base) 2) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 2 binary64)))
#s(approx (/ (pow (* (log base) (atan2 im re)) 2) (* (* (log base) (atan2 im re)) (pow (log base) 2))) #s(hole binary64 (/ (atan2 im re) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (atan2 im re) (/ (log base) (pow (log base) 2))) (/.f64 (atan2.f64 im re) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base)))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3) (atan2 im re))))
#s(approx (* (* (log base) (atan2 im re)) (pow (log base) 2)) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64)) (atan2.f64 im re)))
#s(approx (pow (* (log base) (atan2 im re)) 2) #s(hole binary64 (* (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2) (pow (atan2 im re) 2))))
#s(approx (pow (* (log base) (atan2 im re)) 2) (*.f64 (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 2 binary64)) (pow.f64 (atan2.f64 im re) #s(literal 2 binary64))))
#s(approx (pow (log base) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 3)))
#s(approx (pow (log base) 3) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 3 binary64)))
#s(approx (pow (log base) 6) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 6)))
#s(approx (pow (log base) 6) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 6 binary64)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 4)))
#s(approx (pow (log base) 4) (pow.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) base))) #s(literal 4 binary64)))

rewrite63.0ms (1%)

Memory

0.6MiB live, 97.1MiB allocated; 12ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	36	213
0	57	213
1	136	201
0	537	201

Stop Event

1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit

Counts

21 → 184

Calls

Call 1

Inputs
(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(atan2.f64 im re)
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(log.f64 base)
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 3 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))

Outputs
(*.f64 #s(approx (/ (log base) (pow (log base) 2)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))
(atan2.f64 im re)
#s(approx (/ (log base) (pow (log base) 2)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 base)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 #s(literal 1 binary64) (log.f64 base))
(/.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (log.f64 base)))
(neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 base)))
(neg.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 base))))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))
(.f64 (.f64 #s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (log.f64 base)) (log.f64 base))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))))
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (log.f64 base) (.f64 (log.f64 base) #s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))))
#s(approx (/ (* (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(/.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3/2 binary64))) (pow.f64 (log.f64 base) #s(literal 3/2 binary64)))
(/.f64 (/.f64 (atan2.f64 im re) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (log.f64 base))
(/.f64 (neg.f64 (neg.f64 (atan2.f64 im re))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)))))
(/.f64 (neg.f64 (atan2.f64 im re)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(neg.f64 (/.f64 (neg.f64 (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(neg.f64 (/.f64 (atan2.f64 im re) (neg.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(.f64 (.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))))
(.f64 (log.f64 base) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(/.f64 (.f64 (.f64 (neg.f64 (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (neg.f64 (atan2.f64 im re)) (log.f64 base))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(/.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(*.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (log.f64 base))
(*.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(/.f64 (neg.f64 (*.f64 (neg.f64 (atan2.f64 im re)) (log.f64 base))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))))
(/.f64 (*.f64 (neg.f64 (atan2.f64 im re)) (log.f64 base)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
(neg.f64 (/.f64 (*.f64 (neg.f64 (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
(neg.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)))))
(.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 1/2 binary64)) (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (atan2.f64 im re) #s(literal 1 binary64)) (log.f64 base))
(*.f64 (log.f64 base) (pow.f64 (atan2.f64 im re) #s(literal 1 binary64)))
(*.f64 (log.f64 base) (atan2.f64 im re))
(*.f64 (atan2.f64 im re) (log.f64 base))
(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 1 binary64))
(exp.f64 (.f64 (log.f64 (.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 1 binary64)))
(log.f64 (pow.f64 base (atan2.f64 im re)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1/2 binary64)) (pow.f64 (log.f64 base) #s(literal 1/2 binary64)))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))
(log.f64 base)
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(log.f64 (exp.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (log.f64 base)))
(.f64 (log.f64 base) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(.f64 (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (atan2.f64 im re) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))) (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(neg.f64 (/.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(neg.f64 (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))
(.f64 (log.f64 base) (.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(log.f64 (pow.f64 base (log.f64 base)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))) (/.f64 (pow.f64 (atan2.f64 im re) #s(literal 2 binary64)) (log.f64 base)))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) (/.f64 (pow.f64 (atan2.f64 im re) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base)) (/.f64 (pow.f64 (atan2.f64 im re) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (log.f64 base) (atan2.f64 im re))))
(.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (pow.f64 (atan2.f64 im re) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (pow.f64 (atan2.f64 im re) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))))
(/.f64 (/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) (log.f64 base)) (log.f64 base))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re))) (log.f64 base))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (log.f64 base) (atan2.f64 im re)))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (log.f64 base)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
(/.f64 (neg.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)))) (neg.f64 (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))
(neg.f64 (/.f64 (neg.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))))
(neg.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (neg.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))
(.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
(*.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(log.f64 (exp.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))))
(.f64 (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (atan2.f64 im re)) (log.f64 base))
(.f64 (fabs.f64 (.f64 (log.f64 base) (atan2.f64 im re))) (fabs.f64 (*.f64 (log.f64 base) (atan2.f64 im re))))
(.f64 (exp.f64 (log.f64 (.f64 (log.f64 base) (atan2.f64 im re)))) (exp.f64 (log.f64 (*.f64 (log.f64 base) (atan2.f64 im re)))))
(.f64 (.f64 (neg.f64 (atan2.f64 im re)) (log.f64 base)) (*.f64 (neg.f64 (atan2.f64 im re)) (log.f64 base)))
(*.f64 (pow.f64 (atan2.f64 im re) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (atan2.f64 im re))
(.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (log.f64 base) (atan2.f64 im re)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (atan2.f64 im re) #s(literal 2 binary64)))
(.f64 (log.f64 base) (.f64 (atan2.f64 im re) (*.f64 (log.f64 base) (atan2.f64 im re))))
(.f64 (log.f64 base) (.f64 (log.f64 base) (pow.f64 (atan2.f64 im re) #s(literal 2 binary64))))
(.f64 (atan2.f64 im re) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)))
(pow.f64 (exp.f64 (log.f64 (*.f64 (log.f64 base) (atan2.f64 im re)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))
(exp.f64 (.f64 (log.f64 (.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (.f64 (log.f64 base) (atan2.f64 im re))) #s(literal 2 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 3/2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 base))
(*.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 3 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3/2 binary64))
(pow.f64 (log.f64 base) #s(literal 3 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 3 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 3 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 3 binary64))))
(log.f64 (pow.f64 base (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3/2 binary64))) (pow.f64 (log.f64 base) #s(literal 3/2 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (log.f64 base))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 3/2 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(.f64 (log.f64 base) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 6 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 6 binary64))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 3 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 3 binary64))))
(exp.f64 (.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 3 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 6 binary64))))
(*.f64 (fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (fabs.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 base))
(*.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))

eval36.0ms (0.6%)

Memory: -12.9MiB live, 79.1MiB allocated; 9ms collecting garbage
Compiler: Compiled 7 686 to 868 computations (88.7% saved)

prune20.0ms (0.3%)

Memory

-0.7MiB live, 45.4MiB allocated; 4ms collecting garbage

Pruning

16 alts after pruning (8 fresh and 8 done)

	Pruned	Kept	Total
New	339	8	347
Fresh	6	0	6
Picked	2	3	5
Done	0	5	5
Total	347	16	363

Accuracy

100.0%

Counts

363 → 16

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.5%	(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
	99.2%	(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64)))
✓	99.2%	(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
✓	99.3%	(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.3%	(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(.f64 (atan2.f64 im re) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
✓	99.4%	(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	44.2%	(.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))))
	43.8%	(.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))))
	98.5%	(.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
✓	99.2%	(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.9%	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 6)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	47.0%	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.1%	(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.5%	#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Compiler

Compiled 994 to 363 computations (63.5% saved)

regimes46.0ms (0.7%)

Memory

17.4MiB live, 68.6MiB allocated; 11ms collecting garbage

Accuracy

Total -51.5b remaining (-17579.7%)

Threshold costs -51.5b (-17579.7%)

Counts

33 → 1

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))
(*.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64)))))
(*.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (atan2.f64 im re) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (log.f64 base)) (log.f64 base))
(.f64 (atan2.f64 im re) #s(approx (/ (log base) (pow (log base) 2)) (.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64)))))
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 6)) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 #s(approx (- (* (* (log base) (atan2 im re)) (pow (log base) 2)) 0) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (atan2.f64 im re))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(.f64 #s(approx (/ ( (log base) (atan2 im re)) (pow (log base) 4)) (/.f64 (atan2.f64 im re) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3/2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (.f64 (log.f64 base) (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (.f64 (/.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (atan2.f64 im re) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (.f64 (log.f64 base) (.f64 (atan2.f64 im re) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
(.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (/.f64 (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 base) (atan2.f64 im re)) #s(literal 2 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (/.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (-.f64 (/.f64 (-.f64 (.f64 (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (fma.f64 (.f64 (log.f64 base) (atan2.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (/.f64 (-.f64 (.f64 (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base)) (.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base))) #s(literal 0 binary64)) (fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (atan2.f64 im re)) (log.f64 base) #s(literal 0 binary64))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Calls

5 calls:

13.0ms	(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
8.0ms	base
8.0ms	(log.f64 base)
8.0ms	im
8.0ms	re

Results

Accuracy	Segments	Branch
99.5%	1	`(log.f64 base)`
99.5%	1	`(/.f64 (-.f64 (.f64 (atan2.f64 im re) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
99.5%	1	`re`
99.5%	1	`im`
99.5%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

simplify67.0ms (1.1%)

Memory

-6.5MiB live, 37.7MiB allocated; 11ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	22	21
1	58	19
2	229	15
3	1797	13
4	6321	13

Stop Event

1×	node limit

Calls

Call 1

Inputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

Outputs
#s(approx (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (atan2.f64 im re) (log.f64 base)))

derivations40.0ms (0.6%)

Memory

-7.7MiB live, 35.7MiB allocated; 15ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 35 to 22 computations (37.1% saved)

preprocess12.0ms (0.2%)

Memory: 28.2MiB live, 28.2MiB allocated; 0ms collecting garbage
Compiler: Compiled 126 to 80 computations (36.5% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze264.0ms (4.3%)

sample2.1s (33.5%)

explain423.0ms (6.8%)

preprocess230.0ms (3.7%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify149.0ms (2.4%)

localize63.0ms (1%)

series227.0ms (3.7%)

simplify185.0ms (3%)

rewrite60.0ms (1%)

eval34.0ms (0.6%)

prune12.0ms (0.2%)

simplify128.0ms (2.1%)

localize179.0ms (2.9%)

series177.0ms (2.9%)

simplify110.0ms (1.8%)

rewrite28.0ms (0.4%)

eval20.0ms (0.3%)

prune18.0ms (0.3%)

simplify120.0ms (1.9%)

localize189.0ms (3.1%)

series101.0ms (1.6%)

simplify131.0ms (2.1%)

rewrite23.0ms (0.4%)

eval30.0ms (0.5%)

prune10.0ms (0.2%)

simplify457.0ms (7.4%)

localize120.0ms (1.9%)

series221.0ms (3.6%)

simplify122.0ms (2%)

rewrite63.0ms (1%)

eval36.0ms (0.6%)

prune20.0ms (0.3%)

regimes46.0ms (0.7%)

simplify67.0ms (1.1%)

derivations40.0ms (0.6%)

preprocess12.0ms (0.2%)

end0.0ms (0%)

Profiling