Metrics for sqrt A (should all be same)

start0.0ms (0%)

Memory: 0.1MiB live, 0.0MiB allocated

analyze0.0ms (0%)

Memory

0.6MiB live, 0.7MiB allocated

Algorithm

1×

Search

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

Compiler

Compiled 10 to 4 computations (60% saved)

sample481.0ms (16.8%)

Memory

-20.0MiB live, 841.5MiB allocated

Samples

311.0ms

8 256×

valid

Precisions

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

ival-hypot: 167.0ms (95% of total)

ival-true: 6.0ms (3.4% of total)

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

Bogosity

explain104.0ms (3.6%)

Memory

28.1MiB live, 67.1MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
130	-	3	(3.397533577224967e-160)	`(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))`
0	-	0	-	`(+.f64 (.f64 x x) (.f64 x x))`
0	-	0	-	`(*.f64 x x)`
0	-	0	-	`x`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))`	uflow-rescue	64	0
↳	`(+.f64 (.f64 x x) (.f64 x x))`	underflow	64
↳	`(*.f64 x x)`	underflow	128
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))`	oflow-rescue	63	0
↳	`(+.f64 (.f64 x x) (.f64 x x))`	overflow	63
↳	`(*.f64 x x)`	overflow	126

Confusion

	Predicted +	Predicted -
+	127	3
-	0	126

Precision

1.0

Recall

0.9769230769230769

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	127	0	3
-	0	0	126

Precision?

1.0

Recall?

0.9769230769230769

Freqs

test

number	freq
0	129
1	127

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

25.0ms

512×

valid

Compiler

Compiled 51 to 16 computations (68.6% saved)

Precisions

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

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

ival-mult: 4.0ms (26.8% of total)

ival-add: 2.0ms (13.4% of total)

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

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

preprocess18.0ms (0.6%)

Memory

-23.6MiB live, 18.7MiB allocated

Algorithm

1×	egg-herbie

Rules

42×	`associate-r`
32×	`distribute-lft-neg-in`
32×	`sub-neg`
24×	`neg-sub0`
22×	`distribute-lft-in`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	6	13
1	21	13
2	66	13
3	166	13
4	247	13
5	256	13
6	258	13
0	4	8
0	7	6
1	11	6
2	14	6
3	17	6
0	17	3

Stop Event

1×	iter limit
1×	saturated
1×	iter limit
1×	saturated

Calls

Call 1

Inputs
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))

Outputs
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
(sqrt.f64 (*.f64 (+.f64 x x) x))

Symmetry

(abs x)

Compiler

Compiled 9 to 4 computations (55.6% saved)

eval0.0ms (0%)

Memory: 0.4MiB live, 0.4MiB allocated
Compiler: Compiled 1 to 1 computations (0% saved)

prune1.0ms (0%)

Memory

1.1MiB live, 1.1MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	53.2%	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))

Compiler

Compiled 9 to 4 computations (55.6% saved)

simplify3.0ms (0.1%)

Memory

4.2MiB live, 4.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 3 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 x x)
cost-diff	0	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
cost-diff	320	(+.f64 (.f64 x x) (.f64 x x))

Rules

14×	`lower-*.f32`
12×	`lower-*.f64`
4×	`*-commutative`
4×	`count-2`
4×	`associate-r`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	4	19
0	7	15
1	11	15
2	14	15
3	17	15
0	17	12

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
(+.f64 (.f64 x x) (.f64 x x))
(*.f64 x x)
x

Outputs
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(+.f64 (.f64 x x) (.f64 x x))
(*.f64 (+.f64 x x) x)
(*.f64 x x)
x

localize16.0ms (0.6%)

Memory

25.2MiB live, 25.2MiB allocated

Localize:

Found 3 expressions of interest:

New	Metric	Score
accuracy	0	(*.f64 x x)
accuracy	0.00390625	(+.f64 (.f64 x x) (.f64 x x))
accuracy	29.963682352233448	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))

Samples

12.0ms

256×

valid

Compiler

Compiled 21 to 6 computations (71.4% saved)

Precisions

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

ival-hypot: 4.0ms (56% of total)

ival-mult: 2.0ms (28% of total)

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

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

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

series6.0ms (0.2%)

Memory

-30.3MiB live, 7.3MiB allocated

Counts

3 → 36

Calls

Call 1

Inputs
#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())
#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())

Inputs

#s(alt (+.f64 (*.f64 x x) (*.f64 x x)) (patch (+.f64 (*.f64 x x) (*.f64 x x)) #<representation binary64>) () ())

#s(alt (sqrt.f64 (+.f64 (*.f64 x x) (*.f64 x x))) (patch (sqrt.f64 (+.f64 (*.f64 x x) (*.f64 x x))) #<representation binary64>) () ())

#s(alt (*.f64 x x) (patch (*.f64 x x) #<representation binary64>) () ())

Outputs
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (+.f64 (.f64 x x) (.f64 x x)) (patch (+.f64 (.f64 x x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) (patch (sqrt.f64 (+.f64 (.f64 x x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (.f64 x x) (patch (.f64 x x) #<representation binary64>) () ())) ())

Calls

3 calls:

Time	Variable		Point	Expression
4.0ms	x	@	0	((+ (* x x) (* x x)) (sqrt (+ (* x x) (* x x))) (* x x))
1.0ms	x	@	inf	((+ (* x x) (* x x)) (sqrt (+ (* x x) (* x x))) (* x x))
1.0ms	x	@	-inf	((+ (* x x) (* x x)) (sqrt (+ (* x x) (* x x))) (* x x))

simplify5.0ms (0.2%)

Memory

4.8MiB live, 4.8MiB allocated

Algorithm

1×	egg-herbie

Rules

38×	`lower-*.f64`
38×	`lower-fma.f64`
38×	`lower-fma.f32`
38×	`lower-*.f32`
36×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148

Stop Event

1×	iter limit
1×	saturated

Counts

36 → 36

Calls

Call 1

Inputs
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)

Outputs
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)

rewrite28.0ms (1%)

Memory

24.4MiB live, 24.4MiB allocated

Rules

66×	`lower-*.f32`
64×	`lower-*.f64`
42×	`lower-fma.f64`
42×	`lower-fma.f32`
34×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	4	18
0	7	14
1	23	10
0	160	9

Stop Event

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

Counts

3 → 33

Calls

Call 1

Inputs
(+.f64 (.f64 x x) (.f64 x x))
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
(*.f64 x x)

Outputs
(*.f64 (+.f64 x x) x)
(*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) #s(literal 0 binary64)))
(.f64 (.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64)) (.f64 (+.f64 x x) x)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 x x) (*.f64 x x) #s(literal 0 binary64))))
(.f64 #s(literal 2 binary64) (.f64 x x))
(.f64 (.f64 x x) #s(literal 2 binary64))
(*.f64 x (+.f64 x x))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64)) (.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64)) (.f64 (+.f64 x x) x))))
(/.f64 #s(literal 1 binary64) (*.f64 (+.f64 x x) x))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64)) (.f64 (+.f64 x x) x))) (neg.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64))))
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(/.f64 (.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64)) (.f64 (+.f64 x x) x)) (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64)))
(fma.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)) (*.f64 x x))
(fma.f64 x x (*.f64 x x))
(-.f64 (/.f64 (.f64 (.f64 (.f64 x x) x) x) #s(literal 0 binary64)) (/.f64 (.f64 (.f64 (.f64 x x) x) x) #s(literal 0 binary64)))
(+.f64 (.f64 x x) (.f64 x x))
(.f64 (pow.f64 (.f64 (+.f64 x x) x) #s(literal 1/4 binary64)) (pow.f64 (*.f64 (+.f64 x x) x) #s(literal 1/4 binary64)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (.f64 x x)))
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/2 binary64)) (pow.f64 (.f64 x x) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 (+.f64 x x) #s(literal 1/2 binary64)))
(pow.f64 (*.f64 (+.f64 x x) x) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 #s(literal 0 binary64)) (sqrt.f64 #s(literal 0 binary64)))
(/.f64 (sqrt.f64 (.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64)) (.f64 (+.f64 x x) x))) (sqrt.f64 (fma.f64 (.f64 x x) (.f64 x x) #s(literal 0 binary64))))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) x)
(hypot.f64 x (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 x x)
(exp.f64 (.f64 (log.f64 (.f64 (+.f64 x x) x)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)))
(*.f64 x x)
(pow.f64 x #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 x) #s(literal 2 binary64)))

eval13.0ms (0.4%)

Memory: -24.1MiB live, 13.8MiB allocated
Compiler: Compiled 750 to 96 computations (87.2% saved)

prune7.0ms (0.2%)

Memory

12.9MiB live, 12.9MiB allocated

Pruning

4 alts after pruning (4 fresh and 0 done)

	Pruned	Kept	Total
New	81	4	85
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	82	4	86

Accuracy

100.0%

Counts

86 → 4

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(hypot.f64 x x)
▶	99.5%	(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
▶	53.2%	(sqrt.f64 (*.f64 (+.f64 x x) x))
▶	99.3%	#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))

Compiler

Compiled 25 to 15 computations (40% saved)

simplify4.0ms (0.1%)

Memory

4.1MiB live, 4.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 11 expressions of interest:

New	Metric	Score
cost-diff	5312	(hypot.f64 x x)
cost-diff	0	(+.f64 x x)
cost-diff	0	(sqrt.f64 (+.f64 x x))
cost-diff	0	(sqrt.f64 x)
cost-diff	0	(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
cost-diff	0	(+.f64 x x)
cost-diff	0	(*.f64 (+.f64 x x) x)
cost-diff	0	(sqrt.f64 (*.f64 (+.f64 x x) x))
cost-diff	0	(sqrt.f64 #s(literal 2 binary64))
cost-diff	0	(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
cost-diff	0	#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))

Rules

22×	`lower-*.f32`
16×	`lower-*.f64`
10×	`*-commutative`
8×	`lift-sqrt.f64`
8×	`lower-sqrt.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	52
0	23	49
1	28	49
2	31	49
0	31	49

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(sqrt.f64 #s(literal 2 binary64))
#s(literal 2 binary64)
x
(sqrt.f64 (*.f64 (+.f64 x x) x))
(*.f64 (+.f64 x x) x)
(+.f64 x x)
x
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(sqrt.f64 x)
x
(sqrt.f64 (+.f64 x x))
(+.f64 x x)
(hypot.f64 x x)
x

Outputs
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(sqrt.f64 #s(literal 2 binary64))
#s(literal 2 binary64)
x
(sqrt.f64 (*.f64 (+.f64 x x) x))
(*.f64 (+.f64 x x) x)
(+.f64 x x)
x
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(*.f64 (sqrt.f64 (+.f64 x x)) (sqrt.f64 x))
(sqrt.f64 x)
x
(sqrt.f64 (+.f64 x x))
(+.f64 x x)
(hypot.f64 x x)
(sqrt.f64 (*.f64 (+.f64 x x) x))
x

localize46.0ms (1.6%)

Memory

-3.4MiB live, 34.8MiB allocated

Localize:

Found 11 expressions of interest:

New	Metric	Score
accuracy	0.01171875	(hypot.f64 x x)
accuracy	0	(+.f64 x x)
accuracy	0	(sqrt.f64 (+.f64 x x))
accuracy	0	(sqrt.f64 x)
accuracy	0.33203125	(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
accuracy	0	(+.f64 x x)
accuracy	0	(*.f64 (+.f64 x x) x)
accuracy	29.963682352233448	(sqrt.f64 (*.f64 (+.f64 x x) x))
accuracy	0	(sqrt.f64 #s(literal 2 binary64))
accuracy	0	#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
accuracy	0.43359375	(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)

Samples

38.0ms

256×

valid

Compiler

Compiled 59 to 13 computations (78% saved)

Precisions

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

ival-sqrt: 19.0ms (64.5% of total)

ival-mult: 4.0ms (13.6% of total)

ival-hypot: 4.0ms (13.6% of total)

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

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

exact: 0.0ms (0% of total)

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

series7.0ms (0.3%)

Memory

9.8MiB live, 9.8MiB allocated

Counts

10 → 108

Calls

Call 1

Inputs
#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())
#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())
#s(alt (sqrt.f64 #s(literal 2 binary64)) (patch (sqrt.f64 #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())
#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())
#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())
#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())
#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())
#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())

Outputs
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (sqrt.f64 #s(literal 2 binary64)) x)) (patch #s(approx (sqrt (+ ( x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 #s(literal 2 binary64)) x) (patch (.f64 (sqrt.f64 #s(literal 2 binary64)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (+.f64 x x) x)) (patch (sqrt.f64 (.f64 (+.f64 x x) x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (.f64 (+.f64 x x) x) (patch (.f64 (+.f64 x x) x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) (patch (.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (hypot.f64 x x) (patch (hypot.f64 x x) #<representation binary64>) () ())) ())

Calls

3 calls:

Time

Variable

Point

Expression

3.0ms

-inf

((sqrt (+ (* x x) (* x x))) (* (sqrt 2) x) (sqrt 2) (sqrt (* (+ x x) x)) (* (+ x x) x) (+ x x) (* (sqrt x) (sqrt (+ x x))) (sqrt x) (sqrt (+ x x)) (sqrt (+ (* x x) (* x x))))

1.0ms

inf

((sqrt (+ (* x x) (* x x))) (* (sqrt 2) x) (sqrt 2) (sqrt (* (+ x x) x)) (* (+ x x) x) (+ x x) (* (sqrt x) (sqrt (+ x x))) (sqrt x) (sqrt (+ x x)) (sqrt (+ (* x x) (* x x))))

1.0ms

((sqrt (+ (* x x) (* x x))) (* (sqrt 2) x) (sqrt 2) (sqrt (* (+ x x) x)) (* (+ x x) x) (+ x x) (* (sqrt x) (sqrt (+ x x))) (sqrt x) (sqrt (+ x x)) (sqrt (+ (* x x) (* x x))))

simplify130.0ms (4.5%)

Memory

-3.9MiB live, 38.7MiB allocated

Algorithm

1×	egg-herbie

Rules

1 504×	`associate-r`
1 232×	`lower-*.f64`
1 232×	`lower-fma.f64`
1 232×	`lower-fma.f32`
1 232×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	22	464
1	50	464
2	136	464
3	263	464
4	491	464
5	808	464
6	1417	464
7	1543	464
8	1596	464
9	1634	464
10	1810	464
11	2024	464
12	2070	464
13	2098	464
14	2102	464
15	2102	464
16	2279	464
17	2463	464
18	3584	464
19	3703	464
20	3727	464
21	3735	464
22	3739	464
23	3743	464
24	3855	464
25	3903	464
26	3903	464
27	4089	464
0	4089	464

Stop Event

1×	iter limit
1×	saturated

Counts

108 → 108

Calls

Call 1

Inputs
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 x)
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(sqrt x)
(sqrt x)
(sqrt x)
(sqrt x)
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 x)
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(sqrt x)
(sqrt x)
(sqrt x)
(sqrt x)
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 x)
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))

Outputs
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))
(* -1 (* x (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (neg.f64 x))

rewrite34.0ms (1.2%)

Memory

12.0MiB live, 48.7MiB allocated

Rules

98×	`lower-*.f32`
92×	`lower-*.f64`
68×	`lower-fma.f64`
68×	`lower-fma.f32`
58×	`lower-/.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	15	44
0	23	38
1	51	34
0	255	34

Stop Event

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

Counts

10 → 127

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(sqrt.f64 #s(literal 2 binary64))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(*.f64 (+.f64 x x) x)
(+.f64 x x)
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(sqrt.f64 x)
(sqrt.f64 (+.f64 x x))
(hypot.f64 x x)

Outputs
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(*.f64 x (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(pow.f64 #s(literal 2 binary64) #s(literal 1/2 binary64))
(sqrt.f64 #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)) (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (+.f64 x x)) (sqrt.f64 x))
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 (.f64 x x) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(pow.f64 (+.f64 x x) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (sqrt.f64 #s(literal 0 binary64)) (sqrt.f64 #s(literal 0 binary64)))
(/.f64 (sqrt.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64))))
(sqrt.f64 (+.f64 x x))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) x)
(hypot.f64 x (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 x x)
(exp.f64 (*.f64 (log.f64 (+.f64 x x)) #s(literal 1/2 binary64)))
(.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64))))
(*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) #s(literal 0 binary64)))
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (/.f64 #s(literal 1 binary64) (fma.f64 x x #s(literal 0 binary64))))
(*.f64 (+.f64 x x) x)
(.f64 #s(literal 2 binary64) (.f64 x x))
(*.f64 #s(literal 2 binary64) x)
(.f64 (.f64 x x) #s(literal 2 binary64))
(*.f64 x (+.f64 x x))
(*.f64 x #s(literal 2 binary64))
(/.f64 (*.f64 #s(literal 0 binary64) x) #s(literal 0 binary64))
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))
(/.f64 (.f64 x (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fma.f64 x x #s(literal 0 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x x #s(literal 0 binary64)) (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))))
(/.f64 #s(literal 1 binary64) (+.f64 x x))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))) (neg.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64))))
(/.f64 (neg.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (neg.f64 (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x)) (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64)))
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(/.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (fma.f64 x x #s(literal 0 binary64)))
(fma.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)) (*.f64 x x))
(fma.f64 x x (*.f64 x x))
(-.f64 (/.f64 (.f64 (.f64 (.f64 x x) x) x) #s(literal 0 binary64)) (/.f64 (.f64 (.f64 (.f64 x x) x) x) #s(literal 0 binary64)))
(-.f64 (/.f64 (.f64 x x) #s(literal 0 binary64)) (/.f64 (.f64 x x) #s(literal 0 binary64)))
(+.f64 (.f64 x x) (.f64 x x))
(+.f64 x x)
(.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64))))
(*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) #s(literal 0 binary64)))
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (/.f64 #s(literal 1 binary64) (fma.f64 x x #s(literal 0 binary64))))
(*.f64 (+.f64 x x) x)
(.f64 #s(literal 2 binary64) (.f64 x x))
(*.f64 #s(literal 2 binary64) x)
(.f64 (.f64 x x) #s(literal 2 binary64))
(*.f64 x (+.f64 x x))
(*.f64 x #s(literal 2 binary64))
(/.f64 (*.f64 #s(literal 0 binary64) x) #s(literal 0 binary64))
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))
(/.f64 (.f64 x (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fma.f64 x x #s(literal 0 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x x #s(literal 0 binary64)) (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))))
(/.f64 #s(literal 1 binary64) (+.f64 x x))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))) (neg.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64))))
(/.f64 (neg.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (neg.f64 (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x)) (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64)))
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(/.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (fma.f64 x x #s(literal 0 binary64)))
(fma.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)) (*.f64 x x))
(fma.f64 x x (*.f64 x x))
(-.f64 (/.f64 (.f64 (.f64 (.f64 x x) x) x) #s(literal 0 binary64)) (/.f64 (.f64 (.f64 (.f64 x x) x) x) #s(literal 0 binary64)))
(-.f64 (/.f64 (.f64 x x) #s(literal 0 binary64)) (/.f64 (.f64 x x) #s(literal 0 binary64)))
(+.f64 (.f64 x x) (.f64 x x))
(+.f64 x x)
(*.f64 (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)) (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (+.f64 x x)) (sqrt.f64 x))
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 (.f64 x x) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(pow.f64 (+.f64 x x) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (sqrt.f64 #s(literal 0 binary64)) (sqrt.f64 #s(literal 0 binary64)))
(/.f64 (sqrt.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64))))
(sqrt.f64 (+.f64 x x))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) x)
(hypot.f64 x (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 x x)
(exp.f64 (*.f64 (log.f64 (+.f64 x x)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 x #s(literal 1/4 binary64)) (pow.f64 x #s(literal 1/4 binary64)))
(pow.f64 x #s(literal 1/2 binary64))
(sqrt.f64 x)
(exp.f64 (*.f64 (log.f64 x) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)) (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (+.f64 x x)) (sqrt.f64 x))
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 (.f64 x x) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(pow.f64 (+.f64 x x) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (sqrt.f64 #s(literal 0 binary64)) (sqrt.f64 #s(literal 0 binary64)))
(/.f64 (sqrt.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64))))
(sqrt.f64 (+.f64 x x))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) x)
(hypot.f64 x (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 x x)
(exp.f64 (*.f64 (log.f64 (+.f64 x x)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)) (pow.f64 (+.f64 x x) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (+.f64 x x)) (sqrt.f64 x))
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (.f64 x x)))
(.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 (.f64 x x) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 x))
(pow.f64 (+.f64 x x) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (sqrt.f64 #s(literal 0 binary64)) (sqrt.f64 #s(literal 0 binary64)))
(/.f64 (sqrt.f64 (.f64 (fma.f64 (.f64 (.f64 x x) x) x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 (.f64 (*.f64 x x) x) x #s(literal 0 binary64))))
(sqrt.f64 (+.f64 x x))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 (pow.f64 x #s(literal 1 binary64)) x)
(hypot.f64 x (pow.f64 x #s(literal 1 binary64)))
(hypot.f64 x x)
(exp.f64 (*.f64 (log.f64 (+.f64 x x)) #s(literal 1/2 binary64)))

eval27.0ms (1%)

Memory: -7.2MiB live, 66.0MiB allocated
Compiler: Compiled 2 492 to 228 computations (90.9% saved)

prune32.0ms (1.1%)

Memory

-10.1MiB live, 41.0MiB allocated

Pruning

8 alts after pruning (4 fresh and 4 done)

	Pruned	Kept	Total
New	269	4	273
Fresh	0	0	0
Picked	0	4	4
Done	0	0	0
Total	269	8	277

Accuracy

100.0%

Counts

277 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 x x)
▶	34.4%	(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))
✓	99.5%	(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
▶	26.0%	(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
▶	6.9%	(sqrt.f64 (+.f64 x x))
✓	53.2%	(sqrt.f64 (*.f64 (+.f64 x x) x))
✓	99.3%	#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
▶	99.1%	#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))

Compiler

Compiled 75 to 43 computations (42.7% saved)

simplify129.0ms (4.5%)

Memory

20.1MiB live, 130.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 14 expressions of interest:

New	Metric	Score
cost-diff	0	(sqrt.f64 x)
cost-diff	0	(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))
cost-diff	64	(fma.f64 x x #s(literal 0 binary64))
cost-diff	832	(sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))
cost-diff	0	(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
cost-diff	0	(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
cost-diff	64	(fma.f64 x x #s(literal 0 binary64))
cost-diff	1664	(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))
cost-diff	0	(+.f64 x x)
cost-diff	0	(sqrt.f64 (+.f64 x x))
cost-diff	0	(*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
cost-diff	0	(.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)
cost-diff	0	#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))
cost-diff	12480	(exp.f64 (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))

Rules

5 708×	`lower-*.f32`
5 698×	`lower-*.f64`
4 634×	`lower-fma.f32`
4 632×	`lower-fma.f64`
1 998×	`cube-prod`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	24	169
0	40	146
1	64	121
2	134	115
3	274	107
4	390	107
5	1057	107
6	2350	107
7	3090	107
8	4873	107
9	6837	107
10	7633	107
0	8092	101

Stop Event

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

Calls

Call 1

Inputs
#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))
(.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)
(exp.f64 (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
(log.f64 #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 1/2 binary64)
x
(sqrt.f64 (+.f64 x x))
(+.f64 x x)
x
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(fma.f64 x x #s(literal 0 binary64))
x
#s(literal 0 binary64)
(+.f64 x x)
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))
(sqrt.f64 x)
x
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(fma.f64 x x #s(literal 0 binary64))
#s(literal 0 binary64)
(+.f64 x x)
(sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))

Outputs
#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(exp.f64 (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(sqrt.f64 #s(literal 2 binary64))
(*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 2 binary64)))
(log.f64 #s(literal 2 binary64))
#s(literal 2 binary64)
#s(literal 1/2 binary64)
x
(sqrt.f64 (+.f64 x x))
(+.f64 x x)
x
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))
(*.f64 (+.f64 x x) x)
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
(.f64 (.f64 (*.f64 x x) x) (+.f64 x x))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(.f64 (.f64 x x) (+.f64 x x))
(fma.f64 x x #s(literal 0 binary64))
(*.f64 x x)
x
#s(literal 0 binary64)
(+.f64 x x)
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) (+.f64 x x))) (fabs.f64 x)) (sqrt.f64 x))
(sqrt.f64 x)
x
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
(/.f64 (sqrt.f64 (.f64 (.f64 x x) (+.f64 x x))) (fabs.f64 x))
(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))
(sqrt.f64 (.f64 (.f64 x x) (+.f64 x x)))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(.f64 (.f64 x x) (+.f64 x x))
(fma.f64 x x #s(literal 0 binary64))
(*.f64 x x)
#s(literal 0 binary64)
(+.f64 x x)
(sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))
(fabs.f64 x)

localize92.0ms (3.2%)

Memory

-24.8MiB live, 166.0MiB allocated

Localize:

Found 14 expressions of interest:

New	Metric	Score
accuracy	0.33203125	(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))
accuracy	19.248260551275592	(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))
accuracy	20.64201142631939	(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
accuracy	29.88905595734705	(sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))
accuracy	0.0625	(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
accuracy	0.0703125	(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
accuracy	29.963682352233448	(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
accuracy	43.063314832873026	(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))
accuracy	0	(+.f64 x x)
accuracy	0	(sqrt.f64 (+.f64 x x))
accuracy	0	(log.f64 #s(literal 2 binary64))
accuracy	0	#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))
accuracy	0.43359375	(.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)
accuracy	1.0	(exp.f64 (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))

Samples

71.0ms

256×

valid

Compiler

Compiled 178 to 24 computations (86.5% saved)

Precisions

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

ival-mult: 16.0ms (36.5% of total)

ival-sqrt: 9.0ms (20.5% of total)

ival-add: 5.0ms (11.4% of total)

ival-hypot: 4.0ms (9.1% of total)

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

ival-exp: 3.0ms (6.8% of total)

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

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

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

exact: 0.0ms (0% of total)

series12.0ms (0.4%)

Memory

31.4MiB live, 31.4MiB allocated

Counts

17 → 168

Calls

Call 1

Inputs
#s(alt (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) (patch (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) #<representation binary64>) () ())
#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())
#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())
#s(alt (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())
#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())
#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())
#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())
#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())
#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())
#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())
#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 2 binary64)) (patch (log.f64 #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())
#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())
#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())

Outputs
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt x) (sqrt 2)) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) (patch #s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor -inf x) (#s(alt (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) (patch (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (sqrt.f64 (+.f64 x x)) (patch (sqrt.f64 (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 x x) (patch (+.f64 x x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) (patch (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1)))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())

Calls

3 calls:

Time

Variable

Point

Expression

3.0ms

-inf

((exp (* (log 2) 1/2)) (sqrt (+ (* x x) (* x x))) (* (exp (* (log 2) 1/2)) x) (* (log 2) 1/2) (sqrt (+ x x)) (+ x x) (/ (* (* (+ (* x x) 0) (+ x x)) x) (+ (* x x) 0)) (+ (* x x) 0) (sqrt (/ (* (* (+ (* x x) 0) (+ x x)) x) (+ (* x x) 0))) (* (* (+ (* x x) 0) (+ x x)) x) (sqrt (+ (* x x) 0)) (* (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (sqrt (+ (* x x) 0)))) (sqrt x) (log 2) (* (+ (* x x) 0) (+ x x)) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (sqrt (+ (* x x) 0))) (sqrt (* (+ (* x x) 0) (+ x x))))

2.0ms

inf

((exp (* (log 2) 1/2)) (sqrt (+ (* x x) (* x x))) (* (exp (* (log 2) 1/2)) x) (* (log 2) 1/2) (sqrt (+ x x)) (+ x x) (/ (* (* (+ (* x x) 0) (+ x x)) x) (+ (* x x) 0)) (+ (* x x) 0) (sqrt (/ (* (* (+ (* x x) 0) (+ x x)) x) (+ (* x x) 0))) (* (* (+ (* x x) 0) (+ x x)) x) (sqrt (+ (* x x) 0)) (* (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (sqrt (+ (* x x) 0)))) (sqrt x) (log 2) (* (+ (* x x) 0) (+ x x)) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (sqrt (+ (* x x) 0))) (sqrt (* (+ (* x x) 0) (+ x x))))

2.0ms

((exp (* (log 2) 1/2)) (sqrt (+ (* x x) (* x x))) (* (exp (* (log 2) 1/2)) x) (* (log 2) 1/2) (sqrt (+ x x)) (+ x x) (/ (* (* (+ (* x x) 0) (+ x x)) x) (+ (* x x) 0)) (+ (* x x) 0) (sqrt (/ (* (* (+ (* x x) 0) (+ x x)) x) (+ (* x x) 0))) (* (* (+ (* x x) 0) (+ x x)) x) (sqrt (+ (* x x) 0)) (* (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (sqrt (+ (* x x) 0)))) (sqrt x) (log 2) (* (+ (* x x) 0) (+ x x)) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (sqrt (+ (* x x) 0))) (sqrt (* (+ (* x x) 0) (+ x x))))

simplify224.0ms (7.8%)

Memory

6.9MiB live, 83.0MiB allocated

Algorithm

1×	egg-herbie

Rules

2 694×	`associate-r`
1 940×	`lower-*.f64`
1 940×	`lower-*.f32`
1 936×	`lower-fma.f64`
1 936×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	32	756
1	69	756
2	166	756
3	292	756
4	525	756
5	846	756
6	1459	756
7	1660	756
8	1816	756
9	1912	756
10	2053	756
11	2186	756
12	2229	756
13	2235	756
14	2235	756
15	2395	756
16	3192	756
17	3562	756
18	4052	756
19	4110	756
20	4208	756
21	4258	756
22	4590	756
23	4702	756
24	4702	756
25	4702	756
26	4702	756
27	5206	756
28	5392	756
29	5436	756
30	5450	756
31	5456	756
32	5456	756
33	5456	756
34	5881	756
0	5881	756

Stop Event

1×	iter limit
1×	saturated

Counts

168 → 160

Calls

Call 1

Inputs
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
x
x
x
x
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(sqrt x)
(sqrt x)
(sqrt x)
(sqrt x)
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
x
x
x
x
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(sqrt x)
(sqrt x)
(sqrt x)
(sqrt x)
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt x) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 x)
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* -1 x)
(* -1 x)
(* -1 x)
(* -1 x)
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))

Outputs
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
x
x
x
x
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
x
x
x
x
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt x) (sqrt 2))
(*.f64 (sqrt.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 x)
(*.f64 #s(literal 2 binary64) x)
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(* 2 (pow x 2))
(.f64 #s(literal 2 binary64) (.f64 x x))
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* 2 (pow x 4))
(*.f64 #s(literal 2 binary64) (pow.f64 x #s(literal 4 binary64)))
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* x (* (sqrt -2) (sqrt -1))))
(.f64 (neg.f64 x) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* 2 (pow x 3))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 x x) x))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* -1 (* (sqrt x) (* (sqrt -2) (sqrt -1))))
(neg.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 x)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal -2 binary64)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal -2 binary64)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal -2 binary64)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal -2 binary64)))

rewrite60.0ms (2.1%)

Memory

-24.0MiB live, 98.1MiB allocated

Rules

120×	`lower-/.f64`
120×	`lower-*.f32`
120×	`lower-/.f32`
116×	`lower-*.f64`
68×	`lower-fma.f32`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	24	143
0	40	71
1	125	34
0	920	34

Stop Event

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

Counts

17 → 63

Calls

Call 1

Inputs
(exp.f64 (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))
(.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x)
(*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
(sqrt.f64 (+.f64 x x))
(+.f64 x x)
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64)))
(fma.f64 x x #s(literal 0 binary64))
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
(sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))
(sqrt.f64 x)
(log.f64 #s(literal 2 binary64))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64))))
(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))

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

eval34.0ms (1.2%)

Memory: 16.2MiB live, 92.3MiB allocated
Compiler: Compiled 6 174 to 525 computations (91.5% saved)

prune31.0ms (1.1%)

Memory

-33.6MiB live, 66.1MiB allocated

Pruning

9 alts after pruning (3 fresh and 6 done)

	Pruned	Kept	Total
New	385	3	388
Fresh	0	0	0
Picked	2	2	4
Done	0	4	4
Total	387	9	396

Accuracy

100.0%

Counts

396 → 9

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 x x)
▶	37.9%	(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
✓	99.5%	(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
▶	26.0%	(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
✓	6.9%	(sqrt.f64 (+.f64 x x))
✓	53.2%	(sqrt.f64 (*.f64 (+.f64 x x) x))
✓	99.3%	#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
✓	99.1%	#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))
▶	3.8%	#s(literal 0 binary64)

Compiler

Compiled 73 to 46 computations (37% saved)

simplify133.0ms (4.6%)

Memory

4.7MiB live, 122.4MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 8 expressions of interest:

New	Metric	Score
cost-diff	0	(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))
cost-diff	0	(sqrt.f64 x)
cost-diff	0	(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
cost-diff	64	(fma.f64 x x #s(literal 0 binary64))
cost-diff	0	(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
cost-diff	0	(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
cost-diff	64	(fma.f64 x x #s(literal 0 binary64))
cost-diff	1664	(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x))

Rules

4 900×	`lower-*.f32`
4 892×	`lower-*.f64`
3 892×	`lower-fma.f32`
3 890×	`lower-fma.f64`
2 180×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	14	117
0	26	107
1	50	87
2	118	77
3	297	77
4	632	77
5	2169	77
6	3089	77
7	3741	77
8	4962	77
9	6713	77
10	7500	77
0	8017	74

Stop Event

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

Calls

Call 1

Inputs
#s(literal 0 binary64)
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x))
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(fma.f64 x x #s(literal 0 binary64))
x
#s(literal 0 binary64)
(+.f64 x x)
(*.f64 x x)
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
(sqrt.f64 x)
x
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))
(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(fma.f64 x x #s(literal 0 binary64))
#s(literal 0 binary64)
(+.f64 x x)
(fabs.f64 x)

Outputs
#s(literal 0 binary64)
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x))
(*.f64 (+.f64 x x) x)
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
(.f64 (.f64 (+.f64 x x) x) (*.f64 x x))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(.f64 (.f64 (+.f64 x x) x) x)
(fma.f64 x x #s(literal 0 binary64))
(*.f64 x x)
x
#s(literal 0 binary64)
(+.f64 x x)
(*.f64 x x)
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
(.f64 (/.f64 (sqrt.f64 x) (fabs.f64 x)) (sqrt.f64 (.f64 (*.f64 (+.f64 x x) x) x)))
(sqrt.f64 x)
x
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))
(/.f64 (sqrt.f64 (.f64 (.f64 (+.f64 x x) x) x)) (fabs.f64 x))
(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))
(sqrt.f64 (.f64 (.f64 (+.f64 x x) x) x))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(.f64 (.f64 (+.f64 x x) x) x)
(fma.f64 x x #s(literal 0 binary64))
(*.f64 x x)
#s(literal 0 binary64)
(+.f64 x x)
(fabs.f64 x)

localize72.0ms (2.5%)

Memory

2.1MiB live, 40.6MiB allocated

Localize:

Found 8 expressions of interest:

New	Metric	Score
accuracy	0.0625	(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
accuracy	0.33203125	(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
accuracy	19.248260551275592	(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))
accuracy	20.64201142631939	(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))
accuracy	0.0625	(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
accuracy	0.0703125	(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
accuracy	29.963682352233448	(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
accuracy	43.063314832873026	(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x))

Samples

61.0ms

256×

valid

Compiler

Compiled 129 to 16 computations (87.6% saved)

Precisions

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

ival-fabs: 36.0ms (68.9% of total)

ival-mult: 6.0ms (11.5% of total)

ival-sqrt: 5.0ms (9.6% of total)

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

ival-add: 2.0ms (3.8% of total)

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

exact: 0.0ms (0% of total)

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

series14.0ms (0.5%)

Memory

15.1MiB live, 15.1MiB allocated

Counts

9 → 108

Calls

Call 1

Inputs
#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())
#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())
#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())
#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())
#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())
#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())
#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())

Outputs
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor 0 x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor 0 x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor 0 x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor 0 x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor 0 x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor 0 x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor 0 x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor 0 x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* x (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (sqrt 2)) (fabs x)) (taylor inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (sqrt x) (taylor inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x))) (taylor inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (sqrt 2)) (taylor inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 2)) (taylor -inf x) (#s(alt (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) (patch (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (pow x 2) (taylor -inf x) (#s(alt (fma.f64 x x #s(literal 0 binary64)) (patch (fma.f64 x x #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (sqrt 2))) (taylor -inf x) (#s(alt (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) (patch (sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 4)) (taylor -inf x) (#s(alt (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (patch (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x)) (taylor -inf x) (#s(alt (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) (patch (.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (sqrt x) (pow (sqrt -1) 2))) (taylor -inf x) (#s(alt (sqrt.f64 x) (patch (sqrt.f64 x) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x))) (taylor -inf x) (#s(alt (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) (patch (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* 2 (pow x 3)) (taylor -inf x) (#s(alt (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) (patch (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1))) (taylor -inf x) (#s(alt (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (patch (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) #<representation binary64>) () ())) ())

Calls

3 calls:

Time

Variable

Point

Expression

5.0ms

-inf

((/ (* (* (+ (* x x) 0) (+ x x)) x) (* x x)) (+ (* x x) 0) (sqrt (/ (* (* (+ (* x x) 0) (+ x x)) x) (* x x))) (* (* (+ (* x x) 0) (+ x x)) x) (* (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (fabs x))) (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (fabs x)) (* (+ (* x x) 0) (+ x x)) (sqrt (* (+ (* x x) 0) (+ x x))))

3.0ms

inf

((/ (* (* (+ (* x x) 0) (+ x x)) x) (* x x)) (+ (* x x) 0) (sqrt (/ (* (* (+ (* x x) 0) (+ x x)) x) (* x x))) (* (* (+ (* x x) 0) (+ x x)) x) (* (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (fabs x))) (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (fabs x)) (* (+ (* x x) 0) (+ x x)) (sqrt (* (+ (* x x) 0) (+ x x))))

2.0ms

((/ (* (* (+ (* x x) 0) (+ x x)) x) (* x x)) (+ (* x x) 0) (sqrt (/ (* (* (+ (* x x) 0) (+ x x)) x) (* x x))) (* (* (+ (* x x) 0) (+ x x)) x) (* (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (fabs x))) (sqrt x) (/ (sqrt (* (+ (* x x) 0) (+ x x))) (fabs x)) (* (+ (* x x) 0) (+ x x)) (sqrt (* (+ (* x x) 0) (+ x x))))

simplify270.0ms (9.4%)

Memory

3.1MiB live, 41.4MiB allocated

Algorithm

1×	egg-herbie

Rules

2 364×	`lower-*.f64`
2 364×	`lower-*.f32`
2 360×	`lower-fma.f64`
2 360×	`lower-fma.f32`
1 506×	`unsub-neg`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	34	640
1	68	640
2	152	640
3	265	640
4	437	640
5	544	640
6	823	640
7	1606	640
8	3152	640
9	4405	640
10	4848	640
11	5436	640
12	5632	640
13	5733	640
14	6046	640
15	6225	640
16	6282	640
17	6296	640
18	6296	640
19	6296	640
20	6296	640
21	6378	640
22	6434	640
23	6450	640
24	6450	640
25	6450	640
26	6458	640
0	6458	640

Stop Event

1×	iter limit
1×	saturated

Counts

108 → 108

Calls

Call 1

Inputs
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(sqrt x)
(sqrt x)
(sqrt x)
(sqrt x)
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* x (sqrt 2))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(sqrt x)
(sqrt x)
(sqrt x)
(sqrt x)
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* (sqrt (pow x 3)) (sqrt 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(* 2 (pow x 2))
(pow x 2)
(pow x 2)
(pow x 2)
(pow x 2)
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* -1 (* x (sqrt 2)))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(* 2 (pow x 4))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* 2 (pow x 3))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))

Outputs
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* x (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) x)
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(/ (* (pow x 2) (sqrt 2)) (fabs x))
(.f64 (/.f64 x (fabs.f64 x)) (.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(sqrt x)
(sqrt.f64 x)
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (/ (sqrt 2) (fabs x)))
(.f64 (/.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal 2 binary64)))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* (sqrt (pow x 3)) (sqrt 2))
(.f64 (sqrt.f64 (.f64 (*.f64 x x) x)) (sqrt.f64 #s(literal 2 binary64)))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(* 2 (pow x 2))
(.f64 (.f64 x x) #s(literal 2 binary64))
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(pow x 2)
(*.f64 x x)
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* x (sqrt 2)))
(*.f64 (neg.f64 x) (sqrt.f64 #s(literal 2 binary64)))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(* 2 (pow x 4))
(*.f64 (pow.f64 x #s(literal 4 binary64)) #s(literal 2 binary64))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(/.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) x) (*.f64 (sqrt.f64 #s(literal -2 binary64)) x)) (fabs.f64 x))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(/.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) x) (*.f64 (sqrt.f64 #s(literal -2 binary64)) x)) (fabs.f64 x))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(/.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) x) (*.f64 (sqrt.f64 #s(literal -2 binary64)) x)) (fabs.f64 x))
(/ (* (pow x 2) (* (sqrt -2) (sqrt -1))) (fabs x))
(/.f64 (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) x) (*.f64 (sqrt.f64 #s(literal -2 binary64)) x)) (fabs.f64 x))
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* -1 (* (sqrt x) (pow (sqrt -1) 2)))
(sqrt.f64 x)
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(.f64 (.f64 (/.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 #s(literal -1 binary64)))
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(.f64 (.f64 (/.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 #s(literal -1 binary64)))
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(.f64 (.f64 (/.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 #s(literal -1 binary64)))
(* (sqrt (pow x 3)) (/ (* (sqrt -2) (sqrt -1)) (fabs x)))
(.f64 (.f64 (/.f64 (sqrt.f64 (.f64 (.f64 x x) x)) (fabs.f64 x)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 #s(literal -1 binary64)))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* 2 (pow x 3))
(.f64 (.f64 (*.f64 x x) x) #s(literal 2 binary64))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (.f64 (.f64 x x) x)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (.f64 (.f64 x x) x)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (.f64 (.f64 x x) x)))
(* (sqrt (pow x 3)) (* (sqrt -2) (sqrt -1)))
(.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (.f64 (.f64 x x) x)))

rewrite50.0ms (1.7%)

Memory

-15.3MiB live, 23.4MiB allocated

Rules

118×	`lower-/.f64`
118×	`lower-/.f32`
106×	`lower-*.f32`
104×	`lower-*.f64`
64×	`lower-fma.f32`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	14	89
0	26	96
1	99	12
0	884	12

Stop Event

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

Counts

9 → 33

Calls

Call 1

Inputs
(/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x))
(fma.f64 x x #s(literal 0 binary64))
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
(.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x)
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
(sqrt.f64 x)
(/.f64 (sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x))
(*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))
(sqrt.f64 (*.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)))

Outputs
#s(literal 0 binary64)
(.f64 (.f64 (.f64 (.f64 x x) x) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)))
(.f64 (.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 x x)) (/.f64 #s(literal 1 binary64) (.f64 (.f64 (*.f64 x x) x) x)))
(*.f64 (fabs.f64 x) (fabs.f64 x))
(*.f64 x x)
(pow.f64 x #s(literal 2 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (.f64 (.f64 x x) x) x)) (.f64 (neg.f64 x) x))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 x x)) #s(literal 0 binary64)) (.f64 (.f64 (.f64 x x) x) x))
(/.f64 (neg.f64 (.f64 (.f64 (.f64 x x) x) x)) (.f64 (neg.f64 x) x))
(/.f64 (neg.f64 (.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 x x))) (neg.f64 (.f64 (.f64 (.f64 x x) x) x)))
(/.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 x x))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 x x) (.f64 (.f64 (.f64 x x) x) x)))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 x x))))
(/.f64 (.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 x x)) (.f64 (.f64 (.f64 x x) x) x))
(fma.f64 (.f64 (.f64 (.f64 x x) x) x) (/.f64 #s(literal 1 binary64) (.f64 x x)) #s(literal 0 binary64))
(fma.f64 (.f64 (.f64 (.f64 (.f64 x x) x) x) (.f64 x x)) (/.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 x x) x) x)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 x) (fabs.f64 x) #s(literal 0 binary64))
(fma.f64 x x #s(literal 0 binary64))
(-.f64 (fma.f64 x x (.f64 x x)) (.f64 x x))
(-.f64 (*.f64 x x) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 x) #s(literal 2 binary64)))
(+.f64 (*.f64 x x) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 x x))
#s(literal 0 binary64)
#s(literal 0 binary64)
#s(literal 0 binary64)
(*.f64 (pow.f64 x #s(literal 1/4 binary64)) (pow.f64 x #s(literal 1/4 binary64)))
(pow.f64 x #s(literal 1/2 binary64))
(sqrt.f64 x)
(exp.f64 (*.f64 (log.f64 x) #s(literal 1/2 binary64)))
#s(literal 0 binary64)
#s(literal 0 binary64)
#s(literal 0 binary64)

eval16.0ms (0.6%)

Memory: 22.8MiB live, 22.8MiB allocated
Compiler: Compiled 2 831 to 261 computations (90.8% saved)

prune39.0ms (1.4%)

Memory

-14.9MiB live, 26.7MiB allocated

Pruning

9 alts after pruning (2 fresh and 7 done)

	Pruned	Kept	Total
New	186	2	188
Fresh	0	0	0
Picked	2	1	3
Done	0	6	6
Total	188	9	197

Accuracy

100.0%

Counts

197 → 9

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	(hypot.f64 x x)
	37.9%	(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (*.f64 x x) (+.f64 x x))) (fabs.f64 x)))
✓	99.5%	(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
	26.0%	(sqrt.f64 (/.f64 (.f64 (.f64 (.f64 x x) (+.f64 x x)) x) (.f64 x x)))
✓	6.9%	(sqrt.f64 (+.f64 x x))
✓	53.2%	(sqrt.f64 (*.f64 (+.f64 x x) x))
✓	99.3%	#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
✓	99.1%	#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))
✓	3.8%	#s(literal 0 binary64)

Compiler

Compiled 206 to 84 computations (59.2% saved)

regimes25.0ms (0.9%)

Memory

-18.4MiB live, 20.4MiB allocated

Counts

14 → 1

Calls

Call 1

Inputs
#s(literal 0 binary64)
(sqrt.f64 (+.f64 x x))
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(sqrt.f64 (/.f64 (.f64 (.f64 (.f64 x x) (+.f64 x x)) x) (.f64 x x)))
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (*.f64 x x) (+.f64 x x))) (fabs.f64 x)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))
(hypot.f64 x x)
#s(approx (sqrt (+ (* x x) (* x x))) (.f64 (exp.f64 (.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) x))

Outputs
(hypot.f64 x x)

Calls

4 calls:

12.0ms	x
4.0ms	(*.f64 x x)
4.0ms	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
4.0ms	(+.f64 (.f64 x x) (.f64 x x))

Results

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

Compiler

Compiled 23 to 10 computations (56.5% saved)

regimes16.0ms (0.5%)

Memory

17.9MiB live, 17.9MiB allocated

Counts

12 → 1

Calls

Call 1

Inputs
#s(literal 0 binary64)
(sqrt.f64 (+.f64 x x))
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(sqrt.f64 (/.f64 (.f64 (.f64 (.f64 x x) (+.f64 x x)) x) (.f64 x x)))
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (*.f64 x x)))
(sqrt.f64 (/.f64 (.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x)) x) (fma.f64 x x #s(literal 0 binary64))))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (*.f64 x x) (+.f64 x x))) (fabs.f64 x)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (fabs.f64 x)))
(.f64 (sqrt.f64 x) (/.f64 (sqrt.f64 (.f64 (fma.f64 x x #s(literal 0 binary64)) (+.f64 x x))) (sqrt.f64 (fma.f64 x x #s(literal 0 binary64)))))

Outputs
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))

Calls

4 calls:

4.0ms	x
4.0ms	(*.f64 x x)
4.0ms	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
4.0ms	(+.f64 (.f64 x x) (.f64 x x))

Results

Accuracy	Segments	Branch
99.5%	1	`x`
99.5%	1	`(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))`
99.5%	1	`(+.f64 (.f64 x x) (.f64 x x))`
99.5%	1	`(*.f64 x x)`

Compiler

Compiled 23 to 10 computations (56.5% saved)

regimes9.0ms (0.3%)

Memory

12.3MiB live, 12.3MiB allocated

Counts

5 → 1

Calls

Call 1

Inputs
#s(literal 0 binary64)
(sqrt.f64 (+.f64 x x))
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(sqrt.f64 (*.f64 (+.f64 x x) x))
(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))

Outputs
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))

Calls

4 calls:

2.0ms	x
2.0ms	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
2.0ms	(*.f64 x x)
2.0ms	(+.f64 (.f64 x x) (.f64 x x))

Results

Accuracy	Segments	Branch
99.3%	1	`x`
99.3%	1	`(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))`
99.3%	1	`(+.f64 (.f64 x x) (.f64 x x))`
99.3%	1	`(*.f64 x x)`

Compiler

Compiled 23 to 10 computations (56.5% saved)

regimes511.0ms (17.8%)

Memory

-29.4MiB live, 9.7MiB allocated

Counts

2 → 1

Calls

Call 1

Inputs
#s(literal 0 binary64)
(sqrt.f64 (+.f64 x x))

Outputs
(sqrt.f64 (+.f64 x x))

Calls

4 calls:

506.0ms	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
2.0ms	x
1.0ms	(+.f64 (.f64 x x) (.f64 x x))
1.0ms	(*.f64 x x)

Results

Accuracy	Segments	Branch
6.9%	1	`x`
6.9%	1	`(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))`
6.9%	1	`(+.f64 (.f64 x x) (.f64 x x))`
6.9%	1	`(*.f64 x x)`

Compiler

Compiled 23 to 10 computations (56.5% saved)

regimes5.0ms (0.2%)

Memory

8.0MiB live, 8.0MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs
#s(literal 0 binary64)

Outputs
#s(literal 0 binary64)

Calls

4 calls:

1.0ms	x
1.0ms	(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))
1.0ms	(+.f64 (.f64 x x) (.f64 x x))
1.0ms	(*.f64 x x)

Results

Accuracy	Segments	Branch
3.8%	1	`x`
3.8%	1	`(sqrt.f64 (+.f64 (.f64 x x) (.f64 x x)))`
3.8%	1	`(+.f64 (.f64 x x) (.f64 x x))`
3.8%	1	`(*.f64 x x)`

Compiler

Compiled 23 to 10 computations (56.5% saved)

simplify5.0ms (0.2%)

Memory

6.8MiB live, 6.8MiB allocated

Algorithm

1×	egg-herbie

Rules

4×	`*-commutative_binary64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	14	28
1	16	28

Stop Event

1×

saturated

Calls

Call 1

Inputs
(hypot.f64 x x)
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(sqrt.f64 (+.f64 x x))
#s(literal 0 binary64)

Outputs
(hypot.f64 x x)
(*.f64 (sqrt.f64 x) (sqrt.f64 (+.f64 x x)))
(*.f64 (sqrt.f64 (+.f64 x x)) (sqrt.f64 x))
#s(approx (sqrt (+ (* x x) (* x x))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) x))
(sqrt.f64 (+.f64 x x))
#s(literal 0 binary64)

soundness123.0ms (4.3%)

Memory

10.2MiB live, 89.2MiB allocated

Rules

120×	`lower-/.f64`
120×	`lower-*.f32`
120×	`lower-/.f32`
116×	`lower-*.f64`
98×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148
0	15	44
0	23	38
1	51	34
0	255	34
0	4	18
0	7	14
1	23	10
0	160	9
0	24	143
0	40	71
1	125	34
0	920	34

Stop Event

1×	fuel
1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit
1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit
1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit
1×	iter limit
1×	saturated

Compiler

Compiled 111 to 54 computations (51.4% saved)

preprocess32.0ms (1.1%)

Memory: -1.1MiB live, 75.2MiB allocated
Remove: (abs x)
Compiler: Compiled 76 to 36 computations (52.6% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

Iter	Nodes	Cost
0	6	13
1	21	13
2	66	13
3	166	13
4	247	13
5	256	13
6	258	13
0	4	8
0	7	6
1	11	6
2	14	6
3	17	6
0	17	3

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148
0	15	44
0	23	38
1	51	34
0	255	34
0	4	18
0	7	14
1	23	10
0	160	9
0	24	143
0	40	71
1	125	34
0	920	34

Iter	Nodes	Cost
0	6	13
1	21	13
2	66	13
3	166	13
4	247	13
5	256	13
6	258	13
0	4	8
0	7	6
1	11	6
2	14	6
3	17	6
0	17	3

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148
0	15	44
0	23	38
1	51	34
0	255	34
0	4	18
0	7	14
1	23	10
0	160	9
0	24	143
0	40	71
1	125	34
0	920	34

start0.0ms (0%)

analyze0.0ms (0%)

sample481.0ms (16.8%)

explain104.0ms (3.6%)

preprocess18.0ms (0.6%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify3.0ms (0.1%)

localize16.0ms (0.6%)

series6.0ms (0.2%)

simplify5.0ms (0.2%)

rewrite28.0ms (1%)

eval13.0ms (0.4%)

prune7.0ms (0.2%)

simplify4.0ms (0.1%)

localize46.0ms (1.6%)

series7.0ms (0.3%)

simplify130.0ms (4.5%)

rewrite34.0ms (1.2%)

eval27.0ms (1%)

prune32.0ms (1.1%)

simplify129.0ms (4.5%)

localize92.0ms (3.2%)

series12.0ms (0.4%)

simplify224.0ms (7.8%)

rewrite60.0ms (2.1%)

eval34.0ms (1.2%)

prune31.0ms (1.1%)

simplify133.0ms (4.6%)

localize72.0ms (2.5%)

series14.0ms (0.5%)

simplify270.0ms (9.4%)

rewrite50.0ms (1.7%)

eval16.0ms (0.6%)

prune39.0ms (1.4%)

regimes25.0ms (0.9%)

regimes16.0ms (0.5%)

regimes9.0ms (0.3%)

regimes511.0ms (17.8%)

regimes5.0ms (0.2%)

simplify5.0ms (0.2%)

soundness123.0ms (4.3%)

preprocess32.0ms (1.1%)

end0.0ms (0%)

Profiling

Iter	Nodes	Cost
0	6	13
1	21	13
2	66	13
3	166	13
4	247	13
5	256	13
6	258	13
0	4	8
0	7	6
1	11	6
2	14	6
3	17	6
0	17	3

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148

Iter	Nodes	Cost
0	8	148
1	15	148
2	32	148
3	37	148
4	41	148
5	53	148
6	65	148
7	76	148
8	96	148
9	101	148
0	101	148
0	15	44
0	23	38
1	51	34
0	255	34
0	4	18
0	7	14
1	23	10
0	160	9
0	24	143
0	40	71
1	125	34
0	920	34