Metrics for math.square on complex, real part

start0.0ms (0%)

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

analyze0.0ms (0%)

Memory

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

Algorithm

1×

Search

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

Compiler

Compiled 9 to 7 computations (22.2% saved)

sample582.0ms (53.2%)

Memory

27.0MiB live, 593.2MiB allocated; 105ms collecting garbage

Samples

353.0ms

8 256×

valid

Precisions

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

ival-mult!: 111.0ms (86% of total)

ival-sub!: 16.0ms (12.4% of total)

adjust: 1.0ms (0.8% of total)

Bogosity

explain57.0ms (5.2%)

Memory

24.8MiB live, 109.3MiB allocated; 15ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
20	-	-	`(-.f64 (.f64 re re) (.f64 im im))`
0	-	-	`(*.f64 re re)`
0	-	-	`re`
0	-	-	`(*.f64 im im)`
0	-	-	`im`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`-.f64`	`(-.f64 (.f64 re re) (.f64 im im))`	nan-rescue	20	0
↳	`(*.f64 re re)`	overflow	63
↳	`(*.f64 im im)`	overflow	63

Confusion

	Predicted +	Predicted -
+	20	0
-	0	236

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	20	0	0
-	0	0	236

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	236
1	20

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

21.0ms

512×

valid

Compiler

Compiled 41 to 19 computations (53.7% saved)

Precisions

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

ival-mult!: 5.0ms (79.3% of total)

ival-sub!: 1.0ms (15.9% of total)

adjust: 0.0ms (0% of total)

preprocess50.0ms (4.6%)

Memory

-51.9MiB live, 53.0MiB allocated; 12ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	14	45
1	51	42
2	223	42
3	386	42
4	950	42
5	1955	42
6	2959	42
7	3299	42
8	3377	42
9	3377	42
10	3570	42

Stop Event

1×

saturated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	92.2%	(-.f64 (.f64 re re) (.f64 im im))

Symmetry

(abs re)

(abs im)

Compiler

Compiled 14 to 10 computations (28.6% saved)

series4.0ms (0.4%)

Memory

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

Counts

5 → 10

Calls

Call 1

Inputs
(-.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im

Outputs
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (- (pow re 2) (pow im 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (+ (* -1 (pow im 2)) (pow re 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 2) (pow im 2)) 1))))

Calls

6 calls:

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

rewrite66.0ms (6%)

Memory

-6.9MiB live, 84.7MiB allocated; 9ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	33	135
0	34	131
1	134	130
0	1189	129

Stop Event

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

Counts

15 → 129

Calls

Call 1

Inputs
(-.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (- (pow re 2) (pow im 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (+ (* -1 (pow im 2)) (pow re 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 2) (pow im 2)) 1))))

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

eval11.0ms (1%)

Memory: 30.4MiB live, 30.4MiB allocated; 0ms collecting garbage
Compiler: Compiled 1 624 to 299 computations (81.6% saved)

prune4.0ms (0.3%)

Memory

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

Pruning

3 alts after pruning (3 fresh and 0 done)

	Pruned	Kept	Total
New	122	3	125
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	123	3	126

Accuracy

100.0%

Counts

126 → 3

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(*.f64 (-.f64 re im) (+.f64 im re))
▶	52.8%	#s(approx (- (* re re) (* im im)) (*.f64 (neg.f64 im) im))
▶	54.0%	#s(approx (- (* re re) (* im im)) (*.f64 re re))

Compiler

Compiled 30 to 20 computations (33.3% saved)

series25.0ms (2.3%)

Memory

-38.9MiB live, 19.1MiB allocated; 24ms collecting garbage

Counts

10 → 39

Calls

Call 1

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

Outputs
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (- (pow re 2) (pow im 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (* -1 im))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (+ re (* -1 im)))))))
#s(approx (- re im) #s(hole binary64 (* -1 im)))
#s(approx (- re im) #s(hole binary64 (- re im)))
#s(approx (+ im re) #s(hole binary64 im))
#s(approx (+ im re) #s(hole binary64 (+ im re)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (pow re 2)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (/ im re))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)))))))
#s(approx (- re im) #s(hole binary64 re))
#s(approx (- re im) #s(hole binary64 (* re (+ 1 (* -1 (/ im re))))))
#s(approx (+ im re) #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 (* re (+ 1 (/ im re)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (+ (* -1 (+ im (* -1 im))) (/ (pow im 2) re)) re))))))
#s(approx (- re im) #s(hole binary64 (* -1 (* re (- (/ im re) 1)))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* re (- (* -1 (/ im re)) 1)))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (+ (* -1 (pow im 2)) (pow re 2))))
#s(approx (* (neg im) im) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx im #s(hole binary64 im))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (* -1 re))) (pow re 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (+ (* -1 im) (* -1 re)))) (pow re 2))))
#s(approx (- re im) #s(hole binary64 (+ re (* -1 im))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 2) (pow im 2)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (/ re im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (+ (/ re im) (/ (pow re 2) (pow im 2)))) 1))))
#s(approx (- re im) #s(hole binary64 (* im (- (/ re im) 1))))
#s(approx (+ im re) #s(hole binary64 (* im (+ 1 (/ re im)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (* -1 re)) im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (+ (* -1 re) (* -1 (/ (pow re 2) im)))) im)) 1))))
#s(approx (- re im) #s(hole binary64 (* -1 (* im (+ 1 (* -1 (/ re im)))))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* im (- (* -1 (/ re im)) 1)))))

Calls

6 calls:

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

rewrite46.0ms (4.2%)

Memory

20.4MiB live, 68.0MiB allocated; 4ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	145	630
0	151	579
0	815	571

Stop Event

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

Counts

49 → 85

Calls

Call 1

Inputs
#s(approx (- (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
re
#s(approx (- (* re re) (* im im)) (*.f64 (neg.f64 im) im))
(*.f64 (neg.f64 im) im)
(neg.f64 im)
im
(*.f64 (-.f64 re im) (+.f64 im re))
(-.f64 re im)
(+.f64 im re)
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (- (pow re 2) (pow im 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (* -1 im))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (+ re (* -1 im)))))))
#s(approx (- re im) #s(hole binary64 (* -1 im)))
#s(approx (- re im) #s(hole binary64 (- re im)))
#s(approx (+ im re) #s(hole binary64 im))
#s(approx (+ im re) #s(hole binary64 (+ im re)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (pow re 2)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (/ im re))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)))))))
#s(approx (- re im) #s(hole binary64 re))
#s(approx (- re im) #s(hole binary64 (* re (+ 1 (* -1 (/ im re))))))
#s(approx (+ im re) #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 (* re (+ 1 (/ im re)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (+ (* -1 (+ im (* -1 im))) (/ (pow im 2) re)) re))))))
#s(approx (- re im) #s(hole binary64 (* -1 (* re (- (/ im re) 1)))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* re (- (* -1 (/ im re)) 1)))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (+ (* -1 (pow im 2)) (pow re 2))))
#s(approx (* (neg im) im) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx im #s(hole binary64 im))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (* -1 re))) (pow re 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (+ (* -1 im) (* -1 re)))) (pow re 2))))
#s(approx (- re im) #s(hole binary64 (+ re (* -1 im))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 2) (pow im 2)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (/ re im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (+ (/ re im) (/ (pow re 2) (pow im 2)))) 1))))
#s(approx (- re im) #s(hole binary64 (* im (- (/ re im) 1))))
#s(approx (+ im re) #s(hole binary64 (* im (+ 1 (/ re im)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (* -1 re)) im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (+ (* -1 re) (* -1 (/ (pow re 2) im)))) im)) 1))))
#s(approx (- re im) #s(hole binary64 (* -1 (* im (+ 1 (* -1 (/ re im)))))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* im (- (* -1 (/ re im)) 1)))))

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

eval7.0ms (0.6%)

Memory: 13.6MiB live, 13.6MiB allocated; 0ms collecting garbage
Compiler: Compiled 1 135 to 253 computations (77.7% saved)

prune5.0ms (0.5%)

Memory

-39.7MiB live, 6.5MiB allocated; 3ms collecting garbage

Pruning

5 alts after pruning (2 fresh and 3 done)

	Pruned	Kept	Total
New	76	2	78
Fresh	0	0	0
Picked	0	3	3
Done	0	0	0
Total	76	5	81

Accuracy

100.0%

Counts

81 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(*.f64 (-.f64 re im) (+.f64 im re))
▶	52.2%	(*.f64 #s(approx (- re im) (neg.f64 im)) (+.f64 im re))
▶	53.7%	(*.f64 #s(approx (- re im) re) (+.f64 im re))
✓	52.8%	#s(approx (- (* re re) (* im im)) (*.f64 (neg.f64 im) im))
✓	54.0%	#s(approx (- (* re re) (* im im)) (*.f64 re re))

Compiler

Compiled 49 to 33 computations (32.7% saved)

series3.0ms (0.2%)

Memory

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

Counts

8 → 31

Calls

Call 1

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

Outputs
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (* -1 im))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (+ re (* -1 im)))))))
#s(approx (- re im) #s(hole binary64 (* -1 im)))
#s(approx (- re im) #s(hole binary64 (- re im)))
#s(approx re #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 im))
#s(approx (+ im re) #s(hole binary64 (+ im re)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (pow re 2)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (/ im re))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)))))))
#s(approx (- re im) #s(hole binary64 re))
#s(approx (- re im) #s(hole binary64 (* re (+ 1 (* -1 (/ im re))))))
#s(approx (+ im re) #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 (* re (+ 1 (/ im re)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (+ (* -1 (+ im (* -1 im))) (/ (pow im 2) re)) re))))))
#s(approx (- re im) #s(hole binary64 (* -1 (* re (- (/ im re) 1)))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* re (- (* -1 (/ im re)) 1)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (* -1 re))) (pow re 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (+ (* -1 im) (* -1 re)))) (pow re 2))))
#s(approx (- re im) #s(hole binary64 (+ re (* -1 im))))
#s(approx im #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (/ re im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (+ (/ re im) (/ (pow re 2) (pow im 2)))) 1))))
#s(approx (- re im) #s(hole binary64 (* im (- (/ re im) 1))))
#s(approx (+ im re) #s(hole binary64 (* im (+ 1 (/ re im)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (* -1 re)) im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (+ (* -1 re) (* -1 (/ (pow re 2) im)))) im)) 1))))
#s(approx (- re im) #s(hole binary64 (* -1 (* im (+ 1 (* -1 (/ re im)))))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* im (- (* -1 (/ re im)) 1)))))

Calls

6 calls:

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

rewrite43.0ms (3.9%)

Memory

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	124	503
0	131	457
0	737	449

Stop Event

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

Counts

39 → 54

Calls

Call 1

Inputs
(*.f64 #s(approx (- re im) re) (+.f64 im re))
#s(approx (- re im) re)
re
(+.f64 im re)
im
(*.f64 #s(approx (- re im) (neg.f64 im)) (+.f64 im re))
#s(approx (- re im) (neg.f64 im))
(neg.f64 im)
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (* -1 im))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (+ re (* -1 im)))))))
#s(approx (- re im) #s(hole binary64 (* -1 im)))
#s(approx (- re im) #s(hole binary64 (- re im)))
#s(approx re #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 im))
#s(approx (+ im re) #s(hole binary64 (+ im re)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (pow re 2)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (/ im re))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)))))))
#s(approx (- re im) #s(hole binary64 re))
#s(approx (- re im) #s(hole binary64 (* re (+ 1 (* -1 (/ im re))))))
#s(approx (+ im re) #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 (* re (+ 1 (/ im re)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (+ (* -1 (+ im (* -1 im))) (/ (pow im 2) re)) re))))))
#s(approx (- re im) #s(hole binary64 (* -1 (* re (- (/ im re) 1)))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* re (- (* -1 (/ im re)) 1)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (* -1 re))) (pow re 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (+ (* -1 im) (* -1 re)))) (pow re 2))))
#s(approx (- re im) #s(hole binary64 (+ re (* -1 im))))
#s(approx im #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (/ re im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (+ (/ re im) (/ (pow re 2) (pow im 2)))) 1))))
#s(approx (- re im) #s(hole binary64 (* im (- (/ re im) 1))))
#s(approx (+ im re) #s(hole binary64 (* im (+ 1 (/ re im)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (* -1 re)) im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (+ (* -1 re) (* -1 (/ (pow re 2) im)))) im)) 1))))
#s(approx (- re im) #s(hole binary64 (* -1 (* im (+ 1 (* -1 (/ re im)))))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* im (- (* -1 (/ re im)) 1)))))

Outputs
(*.f64 (+.f64 im re) #s(approx (- re im) re))
(*.f64 #s(approx (- re im) re) (+.f64 im re))
(fma.f64 #s(approx (- re im) re) im (*.f64 #s(approx (- re im) re) re))
(fma.f64 im #s(approx (- re im) re) (*.f64 re #s(approx (- re im) re)))
(+.f64 (.f64 im #s(approx (- re im) re)) (.f64 re #s(approx (- re im) re)))
(+.f64 (.f64 #s(approx (- re im) re) im) (.f64 #s(approx (- re im) re) re))
#s(approx (- re im) re)
re
(/.f64 (-.f64 (.f64 im im) (.f64 re re)) (-.f64 im re))
(/.f64 (+.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (fma.f64 im im (-.f64 (.f64 re re) (.f64 im re))))
(+.f64 im re)
(+.f64 re im)
im
(*.f64 (+.f64 im re) #s(approx (- re im) (neg.f64 im)))
(*.f64 #s(approx (- re im) (neg.f64 im)) (+.f64 im re))
(fma.f64 #s(approx (- re im) (neg.f64 im)) im (*.f64 #s(approx (- re im) (neg.f64 im)) re))
(fma.f64 im #s(approx (- re im) (neg.f64 im)) (*.f64 re #s(approx (- re im) (neg.f64 im))))
(+.f64 (.f64 im #s(approx (- re im) (neg.f64 im))) (.f64 re #s(approx (- re im) (neg.f64 im))))
(+.f64 (.f64 #s(approx (- re im) (neg.f64 im)) im) (.f64 #s(approx (- re im) (neg.f64 im)) re))
#s(approx (- re im) (neg.f64 im))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(neg.f64 im)
#s(approx (* (- re im) (+ im re)) (neg.f64 (*.f64 im im)))
#s(approx (* (- re im) (+ im re)) (fma.f64 (.f64 #s(literal 0 binary64) im) re (neg.f64 (.f64 im im))))
#s(approx (* (- re im) (+ im re)) (fma.f64 (+.f64 (+.f64 (neg.f64 im) re) im) re (neg.f64 (*.f64 im im))))
#s(approx (- re im) (neg.f64 im))
#s(approx (- re im) (-.f64 re im))
#s(approx re re)
#s(approx (+ im re) im)
#s(approx (+ im re) (+.f64 im re))
#s(approx (* (- re im) (+ im re)) (*.f64 re re))
#s(approx (* (- re im) (+ im re)) (.f64 (fma.f64 #s(literal 0 binary64) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (* (- re im) (+ im re)) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 (neg.f64 im) re) (/.f64 (neg.f64 (.f64 im im)) (.f64 re re))) (/.f64 im re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (- re im) re)
#s(approx (- re im) (*.f64 (+.f64 (/.f64 (neg.f64 im) re) #s(literal 1 binary64)) re))
#s(approx (+ im re) re)
#s(approx (+ im re) (*.f64 (+.f64 (/.f64 im re) #s(literal 1 binary64)) re))
#s(approx (* (- re im) (+ im re)) (.f64 (+.f64 (neg.f64 (/.f64 (+.f64 (/.f64 (.f64 im im) re) (neg.f64 (.f64 #s(literal 0 binary64) im))) re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (- re im) (*.f64 (neg.f64 re) (-.f64 (/.f64 im re) #s(literal 1 binary64))))
#s(approx (+ im re) (*.f64 (neg.f64 re) (-.f64 (/.f64 (neg.f64 im) re) #s(literal 1 binary64))))
#s(approx (* (- re im) (+ im re)) (fma.f64 (.f64 #s(literal 0 binary64) re) im (.f64 re re)))
#s(approx (* (- re im) (+ im re)) (fma.f64 (+.f64 (+.f64 (neg.f64 re) (neg.f64 im)) re) im (*.f64 re re)))
#s(approx (- re im) (+.f64 (neg.f64 im) re))
#s(approx im im)
#s(approx (neg im) (neg.f64 im))
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 re im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (fma.f64 #s(literal 0 binary64) (/.f64 re im) (/.f64 (.f64 re re) (.f64 im im))) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (- re im) (*.f64 (-.f64 (/.f64 re im) #s(literal 1 binary64)) im))
#s(approx (+ im re) (*.f64 (+.f64 (/.f64 re im) #s(literal 1 binary64)) im))
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (neg.f64 (.f64 #s(literal 0 binary64) (/.f64 re im))) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 #s(literal 0 binary64) re (neg.f64 (/.f64 (.f64 re re) im))) im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (- re im) (*.f64 (neg.f64 im) (+.f64 (/.f64 (neg.f64 re) im) #s(literal 1 binary64))))
#s(approx (+ im re) (*.f64 (neg.f64 im) (-.f64 (/.f64 (neg.f64 re) im) #s(literal 1 binary64))))

eval5.0ms (0.5%)

Memory: 6.0MiB live, 6.0MiB allocated; 0ms collecting garbage
Compiler: Compiled 921 to 183 computations (80.1% saved)

prune25.0ms (2.3%)

Memory

-43.2MiB live, 2.9MiB allocated; 3ms collecting garbage

Pruning

5 alts after pruning (1 fresh and 4 done)

	Pruned	Kept	Total
New	57	1	58
Fresh	0	0	0
Picked	1	1	2
Done	0	3	3
Total	58	5	63

Accuracy

100.0%

Counts

63 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(*.f64 (-.f64 re im) (+.f64 im re))
✓	52.2%	(*.f64 #s(approx (- re im) (neg.f64 im)) (+.f64 im re))
▶	14.5%	(*.f64 #s(approx (- re im) re) #s(approx (+ im re) im))
✓	52.8%	#s(approx (- (* re re) (* im im)) (*.f64 (neg.f64 im) im))
✓	54.0%	#s(approx (- (* re re) (* im im)) (*.f64 re re))

Compiler

Compiled 51 to 34 computations (33.3% saved)

series5.0ms (0.4%)

Memory

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

Counts

5 → 30

Calls

Call 1

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

Outputs
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (* -1 im))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (+ re (* -1 im)))))))
#s(approx (- re im) #s(hole binary64 (* -1 im)))
#s(approx (- re im) #s(hole binary64 (- re im)))
#s(approx re #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 im))
#s(approx (+ im re) #s(hole binary64 (+ im re)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (pow re 2)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (/ im re))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)))))))
#s(approx (- re im) #s(hole binary64 re))
#s(approx (- re im) #s(hole binary64 (* re (+ 1 (* -1 (/ im re))))))
#s(approx (+ im re) #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 (* re (+ 1 (/ im re)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (+ (* -1 (+ im (* -1 im))) (/ (pow im 2) re)) re))))))
#s(approx (- re im) #s(hole binary64 (* -1 (* re (- (/ im re) 1)))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* re (- (* -1 (/ im re)) 1)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (* -1 re))) (pow re 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (+ (* -1 im) (* -1 re)))) (pow re 2))))
#s(approx (- re im) #s(hole binary64 (+ re (* -1 im))))
#s(approx im #s(hole binary64 im))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (/ re im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (+ (/ re im) (/ (pow re 2) (pow im 2)))) 1))))
#s(approx (- re im) #s(hole binary64 (* im (- (/ re im) 1))))
#s(approx (+ im re) #s(hole binary64 (* im (+ 1 (/ re im)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (* -1 re)) im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (+ (* -1 re) (* -1 (/ (pow re 2) im)))) im)) 1))))
#s(approx (- re im) #s(hole binary64 (* -1 (* im (+ 1 (* -1 (/ re im)))))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* im (- (* -1 (/ re im)) 1)))))

Calls

6 calls:

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

rewrite42.0ms (3.8%)

Memory

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	118	483
0	119	438
0	712	430

Stop Event

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

Counts

35 → 36

Calls

Call 1

Inputs
(*.f64 #s(approx (- re im) re) #s(approx (+ im re) im))
#s(approx (- re im) re)
re
#s(approx (+ im re) im)
im
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (* -1 im))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* -1 (pow im 2)) (* re (+ im (+ re (* -1 im)))))))
#s(approx (- re im) #s(hole binary64 (* -1 im)))
#s(approx (- re im) #s(hole binary64 (- re im)))
#s(approx re #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 im))
#s(approx (+ im re) #s(hole binary64 (+ im re)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (pow re 2)))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (/ im re))))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (+ (* -1 (/ im re)) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)))))))
#s(approx (- re im) #s(hole binary64 re))
#s(approx (- re im) #s(hole binary64 (* re (+ 1 (* -1 (/ im re))))))
#s(approx (+ im re) #s(hole binary64 re))
#s(approx (+ im re) #s(hole binary64 (* re (+ 1 (/ im re)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow re 2) (+ 1 (* -1 (/ (+ (* -1 (+ im (* -1 im))) (/ (pow im 2) re)) re))))))
#s(approx (- re im) #s(hole binary64 (* -1 (* re (- (/ im re) 1)))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* re (- (* -1 (/ im re)) 1)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (* -1 re))) (pow re 2))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (+ (* im (+ re (+ (* -1 im) (* -1 re)))) (pow re 2))))
#s(approx (- re im) #s(hole binary64 (+ re (* -1 im))))
#s(approx im #s(hole binary64 im))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (/ re im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (+ (* -1 (/ re im)) (+ (/ re im) (/ (pow re 2) (pow im 2)))) 1))))
#s(approx (- re im) #s(hole binary64 (* im (- (/ re im) 1))))
#s(approx (+ im re) #s(hole binary64 (* im (+ 1 (/ re im)))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (* -1 re)) im)) 1))))
#s(approx (* (- re im) (+ im re)) #s(hole binary64 (* (pow im 2) (- (* -1 (/ (+ re (+ (* -1 re) (* -1 (/ (pow re 2) im)))) im)) 1))))
#s(approx (- re im) #s(hole binary64 (* -1 (* im (+ 1 (* -1 (/ re im)))))))
#s(approx (+ im re) #s(hole binary64 (* -1 (* im (- (* -1 (/ re im)) 1)))))

Outputs
(*.f64 #s(approx (+ im re) im) #s(approx (- re im) re))
(*.f64 #s(approx (- re im) re) #s(approx (+ im re) im))
#s(approx (- re im) re)
re
#s(approx (+ im re) im)
im
#s(approx (* (- re im) (+ im re)) (neg.f64 (*.f64 im im)))
#s(approx (* (- re im) (+ im re)) (fma.f64 (.f64 #s(literal 0 binary64) im) re (neg.f64 (.f64 im im))))
#s(approx (* (- re im) (+ im re)) (fma.f64 (+.f64 (+.f64 (neg.f64 im) re) im) re (neg.f64 (*.f64 im im))))
#s(approx (- re im) (neg.f64 im))
#s(approx (- re im) (-.f64 re im))
#s(approx re re)
#s(approx (+ im re) im)
#s(approx (+ im re) (+.f64 im re))
#s(approx (* (- re im) (+ im re)) (*.f64 re re))
#s(approx (* (- re im) (+ im re)) (.f64 (fma.f64 #s(literal 0 binary64) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (* (- re im) (+ im re)) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 (neg.f64 im) re) (/.f64 (neg.f64 (.f64 im im)) (.f64 re re))) (/.f64 im re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (- re im) re)
#s(approx (- re im) (*.f64 (+.f64 (/.f64 (neg.f64 im) re) #s(literal 1 binary64)) re))
#s(approx (+ im re) re)
#s(approx (+ im re) (*.f64 (+.f64 (/.f64 im re) #s(literal 1 binary64)) re))
#s(approx (* (- re im) (+ im re)) (.f64 (+.f64 (neg.f64 (/.f64 (+.f64 (/.f64 (.f64 im im) re) (neg.f64 (.f64 #s(literal 0 binary64) im))) re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (- re im) (*.f64 (neg.f64 re) (-.f64 (/.f64 im re) #s(literal 1 binary64))))
#s(approx (+ im re) (*.f64 (neg.f64 re) (-.f64 (/.f64 (neg.f64 im) re) #s(literal 1 binary64))))
#s(approx (* (- re im) (+ im re)) (fma.f64 (.f64 #s(literal 0 binary64) re) im (.f64 re re)))
#s(approx (* (- re im) (+ im re)) (fma.f64 (+.f64 (+.f64 (neg.f64 re) (neg.f64 im)) re) im (*.f64 re re)))
#s(approx (- re im) (+.f64 (neg.f64 im) re))
#s(approx im im)
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 re im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (fma.f64 #s(literal 0 binary64) (/.f64 re im) (/.f64 (.f64 re re) (.f64 im im))) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (- re im) (*.f64 (-.f64 (/.f64 re im) #s(literal 1 binary64)) im))
#s(approx (+ im re) (*.f64 (+.f64 (/.f64 re im) #s(literal 1 binary64)) im))
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (neg.f64 (.f64 #s(literal 0 binary64) (/.f64 re im))) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (* (- re im) (+ im re)) (.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 #s(literal 0 binary64) re (neg.f64 (/.f64 (.f64 re re) im))) im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (- re im) (*.f64 (neg.f64 im) (+.f64 (/.f64 (neg.f64 re) im) #s(literal 1 binary64))))
#s(approx (+ im re) (*.f64 (neg.f64 im) (-.f64 (/.f64 (neg.f64 re) im) #s(literal 1 binary64))))

eval3.0ms (0.3%)

Memory: 3.2MiB live, 3.2MiB allocated; 0ms collecting garbage
Compiler: Compiled 507 to 123 computations (75.7% saved)

prune3.0ms (0.3%)

Memory

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

Pruning

5 alts after pruning (0 fresh and 5 done)

	Pruned	Kept	Total
New	29	0	29
Fresh	0	0	0
Picked	0	1	1
Done	0	4	4
Total	29	5	34

Accuracy

100.0%

Counts

34 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(*.f64 (-.f64 re im) (+.f64 im re))
✓	52.2%	(*.f64 #s(approx (- re im) (neg.f64 im)) (+.f64 im re))
✓	14.5%	(*.f64 #s(approx (- re im) re) #s(approx (+ im re) im))
✓	52.8%	#s(approx (- (* re re) (* im im)) (*.f64 (neg.f64 im) im))
✓	54.0%	#s(approx (- (* re re) (* im im)) (*.f64 re re))

Compiler

Compiled 118 to 57 computations (51.7% saved)

regimes12.0ms (1.1%)

Memory

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

Counts

7 → 1

Calls

Call 1

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

Outputs
(*.f64 (-.f64 re im) (+.f64 im re))

Calls

5 calls:

2.0ms	re
2.0ms	im
2.0ms	(-.f64 (.f64 re re) (.f64 im im))
2.0ms	(*.f64 im im)
2.0ms	(*.f64 re re)

Results

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

Compiler

Compiled 15 to 15 computations (0% saved)

regimes34.0ms (3.1%)

Memory

-30.5MiB live, 16.9MiB allocated; 6ms collecting garbage

Counts

5 → 2

Calls

Call 1

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

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

Calls

5 calls:

26.0ms	(*.f64 re re)
2.0ms	im
2.0ms	re
2.0ms	(*.f64 im im)
2.0ms	(-.f64 (.f64 re re) (.f64 im im))

Results

Accuracy	Segments	Branch
79.7%	2	`(*.f64 im im)`
80.7%	2	`(*.f64 re re)`
96.5%	2	`(-.f64 (.f64 re re) (.f64 im im))`
80.7%	2	`re`
79.7%	2	`im`

Compiler

Compiled 15 to 15 computations (0% saved)

regimes6.0ms (0.5%)

Memory

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

Accuracy

Total -25.3b remaining (-86.1%)

Threshold costs -25.3b (-86.1%)

Counts

2 → 1

Calls

Call 1

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

Outputs
#s(approx (- (* re re) (* im im)) (*.f64 re re))

Calls

5 calls:

1.0ms	re
1.0ms	im
1.0ms	(-.f64 (.f64 re re) (.f64 im im))
1.0ms	(*.f64 im im)
1.0ms	(*.f64 re re)

Results

Accuracy	Segments	Branch
54.0%	1	`(*.f64 im im)`
54.0%	1	`im`
54.0%	1	`(*.f64 re re)`
54.0%	1	`re`
54.0%	1	`(-.f64 (.f64 re re) (.f64 im im))`

Compiler

Compiled 15 to 15 computations (0% saved)

bsearch0.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-3.153803748611483e-288	0.0

Compiler

Compiled 10 to 10 computations (0% saved)

derivations14.0ms (1.3%)

Memory

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

Stop Event

1×

done

Compiler

Compiled 51 to 18 computations (64.7% saved)

preprocess43.0ms (4%)

Memory

-1.3MiB live, 43.4MiB allocated; 5ms collecting garbage

Remove

(abs im)

(abs re)

Compiler

Compiled 320 to 154 computations (51.9% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze0.0ms (0%)

sample582.0ms (53.2%)

explain57.0ms (5.2%)

preprocess50.0ms (4.6%)

series4.0ms (0.4%)

rewrite66.0ms (6%)

eval11.0ms (1%)

prune4.0ms (0.3%)

series25.0ms (2.3%)

rewrite46.0ms (4.2%)

eval7.0ms (0.6%)

prune5.0ms (0.5%)

series3.0ms (0.2%)

rewrite43.0ms (3.9%)

eval5.0ms (0.5%)

prune25.0ms (2.3%)

series5.0ms (0.4%)

rewrite42.0ms (3.8%)

eval3.0ms (0.3%)

prune3.0ms (0.3%)

regimes12.0ms (1.1%)

regimes34.0ms (3.1%)

regimes6.0ms (0.5%)

bsearch0.0ms (0%)

derivations14.0ms (1.3%)

preprocess43.0ms (4%)

end0.0ms (0%)

Profiling