Metrics for Optimisation.CirclePacking:place from circle-packing-0.1.0.4, C

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze0.0ms (0%)

Memory

0.6MiB live, 0.6MiB allocated

Algorithm

1×

Search

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

Compiler

Compiled 7 to 7 computations (0% saved)

sample811.0ms (17.2%)

Memory

-4.5MiB live, 883.6MiB allocated

Samples

401.0ms

8 256×

valid

Precisions

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

ival-sqrt: 82.0ms (43.5% of total)

ival-sub: 49.0ms (26% of total)

ival-fabs: 48.0ms (25.4% of total)

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

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

Bogosity

explain108.0ms (2.3%)

Memory

-11.3MiB live, 99.0MiB allocated

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`y`
-	-	`(fabs.f64 (-.f64 x y))`
-	-	`(-.f64 x y)`
-	-	`(sqrt.f64 (fabs.f64 (-.f64 x y)))`
-	-	`x`

Confusion

	Predicted +	Predicted -
+	0	0
-	0	256

Precision

0/0

Recall

0/0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	256

Precision?

0/0

Recall?

0/0

Freqs

test

number	freq
0	256

Total Confusion?

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

Precision?

0/0

Recall?

0/0

Samples

85.0ms

512×

valid

Compiler

Compiled 37 to 19 computations (48.6% saved)

Precisions

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

ival-sub: 43.0ms (81.9% of total)

ival-sqrt: 6.0ms (11.4% of total)

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

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

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

preprocess37.0ms (0.8%)

Memory

6.8MiB live, 49.4MiB allocated

Algorithm

1×	egg-herbie

Rules

80×	`lower-fma.f64`
80×	`lower-fma.f32`
52×	`lower-*.f64`
52×	`lower-*.f32`
50×	`sub-neg`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	31
1	35	27
2	72	27
3	137	27
4	185	27
5	197	27
6	199	27
0	5	5
0	8	5
1	12	5
2	19	5
3	27	5
4	46	5
5	93	5
6	144	5
7	165	5
8	173	5
0	173	5

Stop Event

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

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))

Outputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))

Symmetry

(sort x y)

Compiler

Compiled 5 to 5 computations (0% saved)

eval0.0ms (0%)

Memory: 0.6MiB live, 0.6MiB allocated
Compiler: Compiled 0 to 2 computations (-∞% saved)

prune0.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(sqrt.f64 (fabs.f64 (-.f64 x y)))

Compiler

Compiled 5 to 5 computations (0% saved)

simplify9.0ms (0.2%)

Memory

-16.5MiB live, 20.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 3 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(-.f64 x y)
cost-diff	0	(fabs.f64 (-.f64 x y))
cost-diff	0	(sqrt.f64 (fabs.f64 (-.f64 x y)))

Rules

80×	`lower-fma.f64`
80×	`lower-fma.f32`
52×	`lower-*.f64`
52×	`lower-*.f32`
34×	`sub-neg`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	5	14
0	8	14
1	12	14
2	19	14
3	27	14
4	46	14
5	93	14
6	144	14
7	165	14
8	173	14
0	173	14

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs.f64 (-.f64 x y))
(-.f64 x y)
x
y

Outputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs.f64 (-.f64 x y))
(fabs.f64 (-.f64 y x))
(-.f64 x y)
x
y

localize17.0ms (0.4%)

Memory

9.0MiB live, 47.0MiB allocated

Localize:

Found 3 expressions of interest:

New	Metric	Score
accuracy	0	(-.f64 x y)
accuracy	0	(fabs.f64 (-.f64 x y))
accuracy	0.0078125	(sqrt.f64 (fabs.f64 (-.f64 x y)))

Samples

11.0ms

256×

valid

Compiler

Compiled 16 to 7 computations (56.3% saved)

Precisions

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

ival-sub: 2.0ms (39.3% of total)

ival-sqrt: 2.0ms (39.3% of total)

ival-fabs: 1.0ms (19.6% of total)

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

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

series4.0ms (0.1%)

Memory

10.5MiB live, 10.5MiB allocated

Counts

3 → 72

Calls

Call 1

Inputs
#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())
#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())
#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())

Inputs

#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())

#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())

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

Outputs
#s(alt (sqrt (fabs (- x y))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 y)) (taylor 0 y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 y)) (taylor 0 y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x (* -1 y)) (taylor 0 y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (- (/ x y) 1)) (taylor inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (- (/ x y) 1)) (taylor inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (- (/ x y) 1)) (taylor inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ x (* -1 y)))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ x (* -1 y)))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ x (* -1 y)))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ x (* -1 y)))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (fabs (+ x (* -1 y))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (+ x (* -1 y))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (+ x (* -1 y))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (+ x (* -1 y))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor -inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ 1 (* -1 (/ x y))))) (taylor -inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ 1 (* -1 (/ x y))))) (taylor -inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ 1 (* -1 (/ x y))))) (taylor -inf y) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (* -1 y) (taylor 0 x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (- x y) (taylor 0 x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (- x y) (taylor 0 x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (- x y) (taylor 0 x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- x y))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (- x y)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ y x)))) (taylor inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ y x)))) (taylor inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* -1 (/ y x)))) (taylor inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ y (* -1 x))))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ y (* -1 x))))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ y (* -1 x))))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ y (* -1 x))))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 x y))) (patch (sqrt.f64 (fabs.f64 (-.f64 x y))) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ y (* -1 x)))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ y (* -1 x)))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ y (* -1 x)))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ y (* -1 x)))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 x y)) (patch (fabs.f64 (-.f64 x y)) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ y x) 1))) (taylor -inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ y x) 1))) (taylor -inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (/ y x) 1))) (taylor -inf x) (#s(alt (-.f64 x y) (patch (-.f64 x y) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
1.0ms	x	@	-inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y))
0.0ms	y	@	inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y))
0.0ms	y	@	0	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y))
0.0ms	y	@	-inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y))
0.0ms	x	@	inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y))

simplify232.0ms (4.9%)

Memory

-15.8MiB live, 111.8MiB allocated

Algorithm

1×	egg-herbie

Rules

2 658×	`lower-fma.f64`
2 658×	`lower-fma.f32`
2 540×	`lower-*.f64`
2 540×	`lower-*.f32`
1 962×	`div-sub`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	30	279
1	79	279
2	186	279
3	541	279
4	1596	279
5	2435	279
6	3316	279
7	4901	279
8	5409	279
9	5785	279
10	6306	279
11	6970	279
12	7705	279
0	8082	279

Stop Event

1×	iter limit
1×	node limit

Counts

72 → 69

Calls

Call 1

Inputs
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
x
(+ x (* -1 y))
(+ x (* -1 y))
(+ x (* -1 y))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(* -1 y)
(* y (- (/ x y) 1))
(* y (- (/ x y) 1))
(* y (- (/ x y) 1))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(* -1 y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(* -1 y)
(- x y)
(- x y)
(- x y)
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
x
(* x (+ 1 (* -1 (/ y x))))
(* x (+ 1 (* -1 (/ y x))))
(* x (+ 1 (* -1 (/ y x))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
x
(* -1 (* x (- (/ y x) 1)))
(* -1 (* x (- (/ y x) 1)))
(* -1 (* x (- (/ y x) 1)))

Outputs
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
x
(+ x (* -1 y))
(-.f64 x y)
(+ x (* -1 y))
(-.f64 x y)
(+ x (* -1 y))
(-.f64 x y)
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(* -1 y)
(neg.f64 y)
(* y (- (/ x y) 1))
(-.f64 x y)
(* y (- (/ x y) 1))
(-.f64 x y)
(* y (- (/ x y) 1))
(-.f64 x y)
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 x y))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 x y))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 x y))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 x y))
(* -1 y)
(neg.f64 y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(* -1 y)
(neg.f64 y)
(- x y)
(-.f64 x y)
(- x y)
(-.f64 x y)
(- x y)
(-.f64 x y)
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
(fabs (- x y))
(fabs.f64 (-.f64 x y))
x
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 x y))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 x y))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 x y))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 x y))
x
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)

rewrite163.0ms (3.4%)

Memory

10.1MiB live, 241.1MiB allocated

Rules

4 642×	`lower-/.f64`
4 642×	`lower-/.f32`
4 306×	`lower-fma.f64`
4 306×	`lower-fma.f32`
3 256×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	5	12
0	8	12
1	29	12
2	181	12
3	1675	12
0	8378	12

Stop Event

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

Counts

3 → 322

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(fabs.f64 (-.f64 x y))
(-.f64 x y)

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval155.0ms (3.3%)

Memory: 5.0MiB live, 122.1MiB allocated
Compiler: Compiled 9 124 to 1 402 computations (84.6% saved)

prune11.0ms (0.2%)

Memory

1.2MiB live, 39.0MiB allocated

Pruning

3 alts after pruning (2 fresh and 1 done)

	Pruned	Kept	Total
New	389	2	391
Fresh	0	0	0
Picked	0	1	1
Done	0	0	0
Total	389	3	392

Accuracy

100.0%

Counts

392 → 3

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	54.4%	(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
✓	100.0%	(sqrt.f64 (fabs.f64 (-.f64 x y)))
▶	56.6%	(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))

Compiler

Compiled 25 to 22 computations (12% saved)

simplify673.0ms (14.2%)

Memory

-16.9MiB live, 395.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 8 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(fma.f64 (neg.f64 y) y (*.f64 x x))
cost-diff	0	(fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))
cost-diff	0	(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x))))
cost-diff	0	(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
cost-diff	0	(neg.f64 y)
cost-diff	0	#s(approx (- x y) (neg.f64 y))
cost-diff	0	(fabs.f64 #s(approx (- x y) (neg.f64 y)))
cost-diff	0	(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))

Rules

59 072×	`lower-fma.f32`
59 070×	`lower-fma.f64`
5 192×	`lower-*.f32`
5 190×	`lower-*.f64`
3 692×	`distribute-lft-out`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	82
0	27	82
1	37	82
2	46	82
3	65	82
4	119	82
5	226	82
6	451	82
7	861	82
8	1664	82
9	2703	82
10	4114	82
11	4882	82
12	5185	82
13	5385	82
14	5481	82
15	5481	82
16	6156	82
17	6268	82
18	6380	82
19	6436	82
20	6492	82
21	6492	82
22	6716	82
23	6772	82
24	6772	82
0	8684	82

Stop Event

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

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))
(fabs.f64 #s(approx (- x y) (neg.f64 y)))
#s(approx (- x y) (neg.f64 y))
(neg.f64 y)
y
(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x))))
(fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(neg.f64 y)
y
(*.f64 x x)
x
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(fabs.f64 (+.f64 y x))
(+.f64 y x)

Outputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))
(fabs.f64 #s(approx (- x y) (neg.f64 y)))
#s(approx (- x y) (neg.f64 y))
(neg.f64 y)
y
(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x))))
(fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(neg.f64 y)
y
(*.f64 x x)
x
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(fabs.f64 (+.f64 y x))
(+.f64 y x)

localize50.0ms (1.1%)

Memory

28.3MiB live, 65.0MiB allocated

Localize:

Found 8 expressions of interest:

New	Metric	Score
accuracy	0.0078125	(sqrt.f64 (fabs.f64 (+.f64 y x)))
accuracy	0.48828125	(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
accuracy	1.7499807332389217	(fma.f64 (neg.f64 y) y (*.f64 x x))
accuracy	28.187618430513336	(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x))))
accuracy	0	(neg.f64 y)
accuracy	0	(fabs.f64 #s(approx (- x y) (neg.f64 y)))
accuracy	0.0078125	(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))
accuracy	28.65087030818425	#s(approx (- x y) (neg.f64 y))

Samples

29.0ms

256×

valid

Compiler

Compiled 79 to 17 computations (78.5% saved)

Precisions

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

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

ival-fabs: 4.0ms (21.2% of total)

ival-mult: 3.0ms (15.9% of total)

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

ival-sub: 2.0ms (10.6% of total)

ival-div: 1.0ms (5.3% of total)

ival-neg: 1.0ms (5.3% of total)

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

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

series17.0ms (0.4%)

Memory

-0.7MiB live, 34.3MiB allocated

Counts

9 → 204

Calls

Call 1

Inputs
#s(alt (sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y)))) (patch (sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y)))) #<representation binary64>) () ())
#s(alt (fabs.f64 #s(approx (- x y) (neg.f64 y))) (patch (fabs.f64 #s(approx (- x y) (neg.f64 y))) #<representation binary64>) () ())
#s(alt #s(approx (- x y) (neg.f64 y)) (patch #s(approx (- x y) (neg.f64 y)) #<representation binary64>) () ())
#s(alt (neg.f64 y) (patch (neg.f64 y) #<representation binary64>) () ())
#s(alt (/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x)))) (patch (/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x)))) #<representation binary64>) () ())
#s(alt (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (.f64 x x)))) (patch (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (.f64 x x)))) #<representation binary64>) () ())
#s(alt (fabs.f64 (fma.f64 (neg.f64 y) y (.f64 x x))) (patch (fabs.f64 (fma.f64 (neg.f64 y) y (.f64 x x))) #<representation binary64>) () ())
#s(alt (fma.f64 (neg.f64 y) y (.f64 x x)) (patch (fma.f64 (neg.f64 y) y (.f64 x x)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (fabs.f64 (+.f64 y x))) (patch (sqrt.f64 (fabs.f64 (+.f64 y x))) #<representation binary64>) () ())

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

Calls

6 calls:

Time	Variable		Point	Expression
4.0ms	y	@	0	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (neg y) (/ (sqrt (fabs (+ (* (neg y) y) (* x x)))) (sqrt (fabs (+ y x)))) (sqrt (fabs (+ (* (neg y) y) (* x x)))) (fabs (+ (* (neg y) y) (* x x))) (+ (* (neg y) y) (* x x)) (sqrt (fabs (+ y x))))
2.0ms	y	@	inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (neg y) (/ (sqrt (fabs (+ (* (neg y) y) (* x x)))) (sqrt (fabs (+ y x)))) (sqrt (fabs (+ (* (neg y) y) (* x x)))) (fabs (+ (* (neg y) y) (* x x))) (+ (* (neg y) y) (* x x)) (sqrt (fabs (+ y x))))
2.0ms	x	@	inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (neg y) (/ (sqrt (fabs (+ (* (neg y) y) (* x x)))) (sqrt (fabs (+ y x)))) (sqrt (fabs (+ (* (neg y) y) (* x x)))) (fabs (+ (* (neg y) y) (* x x))) (+ (* (neg y) y) (* x x)) (sqrt (fabs (+ y x))))
2.0ms	x	@	-inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (neg y) (/ (sqrt (fabs (+ (* (neg y) y) (* x x)))) (sqrt (fabs (+ y x)))) (sqrt (fabs (+ (* (neg y) y) (* x x)))) (fabs (+ (* (neg y) y) (* x x))) (+ (* (neg y) y) (* x x)) (sqrt (fabs (+ y x))))
1.0ms	y	@	-inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (neg y) (/ (sqrt (fabs (+ (* (neg y) y) (* x x)))) (sqrt (fabs (+ y x)))) (sqrt (fabs (+ (* (neg y) y) (* x x)))) (fabs (+ (* (neg y) y) (* x x))) (+ (* (neg y) y) (* x x)) (sqrt (fabs (+ y x))))

simplify185.0ms (3.9%)

Memory

-10.3MiB live, 220.2MiB allocated

Algorithm

1×	egg-herbie

Rules

9 114×	`lower-fma.f64`
9 114×	`lower-fma.f32`
2 928×	`lower-*.f64`
2 928×	`lower-*.f32`
1 654×	`unsub-neg`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	64	1314
1	146	1314
2	325	1314
3	1266	1314
4	4149	1314
5	6012	1314
6	7959	1314
0	8057	1314

Stop Event

1×	iter limit
1×	node limit

Counts

204 → 201

Calls

Call 1

Inputs
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
x
(+ x (* -1 y))
(+ x (* -1 y))
(+ x (* -1 y))
(* -1 y)
(* -1 y)
(* -1 y)
(* -1 y)
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(pow x 2)
(+ (* -1 (pow y 2)) (pow x 2))
(+ (* -1 (pow y 2)) (pow x 2))
(+ (* -1 (pow y 2)) (pow x 2))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(* -1 y)
(* y (- (/ x y) 1))
(* y (- (/ x y) 1))
(* y (- (/ x y) 1))
(* -1 y)
(* -1 y)
(* -1 y)
(* -1 y)
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(fabs (- (pow x 2) (pow y 2)))
(fabs (- (pow x 2) (pow y 2)))
(fabs (- (pow x 2) (pow y 2)))
(fabs (- (pow x 2) (pow y 2)))
(* -1 (pow y 2))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(* -1 y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(* -1 y)
(* -1 y)
(* -1 y)
(* -1 y)
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(fabs (- (pow x 2) (pow y 2)))
(fabs (- (pow x 2) (pow y 2)))
(fabs (- (pow x 2) (pow y 2)))
(fabs (- (pow x 2) (pow y 2)))
(* -1 (pow y 2))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(sqrt (fabs (- x (* -1 y))))
(sqrt (fabs (- x (* -1 y))))
(sqrt (fabs (- x (* -1 y))))
(sqrt (fabs (- x (* -1 y))))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(* -1 y)
(- x y)
(- x y)
(- x y)
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(* -1 (pow y 2))
(+ (* -1 (pow y 2)) (pow x 2))
(+ (* -1 (pow y 2)) (pow x 2))
(+ (* -1 (pow y 2)) (pow x 2))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
x
(* x (+ 1 (* -1 (/ y x))))
(* x (+ 1 (* -1 (/ y x))))
(* x (+ 1 (* -1 (/ y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(pow x 2)
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (+ x y)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
x
(* -1 (* x (- (/ y x) 1)))
(* -1 (* x (- (/ y x) 1)))
(* -1 (* x (- (/ y x) 1)))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(pow x 2)
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(sqrt (fabs (- y (* -1 x))))
(sqrt (fabs (- y (* -1 x))))
(sqrt (fabs (- y (* -1 x))))
(sqrt (fabs (- y (* -1 x))))

Outputs
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
x
(+ x (* -1 y))
(-.f64 x y)
(+ x (* -1 y))
(-.f64 x y)
(+ x (* -1 y))
(-.f64 x y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(pow x 2)
(*.f64 x x)
(+ (* -1 (pow y 2)) (pow x 2))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(+ (* -1 (pow y 2)) (pow x 2))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(+ (* -1 (pow y 2)) (pow x 2))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(* -1 y)
(neg.f64 y)
(* y (- (/ x y) 1))
(-.f64 x y)
(* y (- (/ x y) 1))
(-.f64 x y)
(* y (- (/ x y) 1))
(-.f64 x y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(* -1 (pow y 2))
(*.f64 (neg.f64 y) y)
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(* -1 y)
(neg.f64 y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(* -1 y)
(neg.f64 y)
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (- (pow x 2) (pow y 2))) (fabs (- x (* -1 y)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (- (pow x 2) (pow y 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (- (pow x 2) (pow y 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(* -1 (pow y 2))
(*.f64 (neg.f64 y) y)
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow y 2) (- (/ (pow x 2) (pow y 2)) 1))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(sqrt (fabs (- x (* -1 y))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- x (* -1 y))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- x (* -1 y))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- x (* -1 y))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(* -1 y)
(neg.f64 y)
(- x y)
(-.f64 x y)
(- x y)
(-.f64 x y)
(- x y)
(-.f64 x y)
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(* -1 (pow y 2))
(*.f64 (neg.f64 y) y)
(+ (* -1 (pow y 2)) (pow x 2))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(+ (* -1 (pow y 2)) (pow x 2))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(+ (* -1 (pow y 2)) (pow x 2))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
x
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (+ x y))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(pow x 2)
(*.f64 x x)
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (+ x y)))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
x
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (/ (fabs (+ (* -1 (pow y 2)) (pow x 2))) (fabs (- y (* -1 x)))))
(sqrt.f64 (/.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))) (fabs.f64 (+.f64 y x))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(sqrt (fabs (+ (* -1 (pow y 2)) (pow x 2))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y))))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(fabs (+ (* -1 (pow y 2)) (pow x 2)))
(fabs.f64 (fma.f64 (neg.f64 x) x (*.f64 y y)))
(pow x 2)
(*.f64 x x)
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(* (pow x 2) (+ 1 (* -1 (/ (pow y 2) (pow x 2)))))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(sqrt (fabs (- y (* -1 x))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- y (* -1 x))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- y (* -1 x))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))
(sqrt (fabs (- y (* -1 x))))
(sqrt.f64 (fabs.f64 (+.f64 y x)))

rewrite132.0ms (2.8%)

Memory

22.9MiB live, 212.4MiB allocated

Rules

4 246×	`lower-fma.f32`
4 244×	`lower-fma.f64`
3 020×	`lower-*.f32`
3 018×	`lower-*.f64`
2 010×	`lower-/.f32`

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	15	67
0	27	75
1	90	57
2	543	57
3	5733	46
0	9520	46

Stop Event

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

Counts

9 → 358

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))
(fabs.f64 #s(approx (- x y) (neg.f64 y)))
#s(approx (- x y) (neg.f64 y))
(neg.f64 y)
(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
(sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x))))
(fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))
(fma.f64 (neg.f64 y) y (*.f64 x x))
(sqrt.f64 (fabs.f64 (+.f64 y x)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval107.0ms (2.3%)

Memory: -24.3MiB live, 189.5MiB allocated
Compiler: Compiled 10 131 to 1 363 computations (86.5% saved)

prune21.0ms (0.4%)

Memory

14.3MiB live, 58.4MiB allocated

Pruning

4 alts after pruning (2 fresh and 2 done)

	Pruned	Kept	Total
New	595	2	597
Fresh	0	0	0
Picked	1	1	2
Done	0	1	1
Total	596	4	600

Accuracy

100.0%

Counts

600 → 4

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.2%	(/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
✓	54.4%	(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
✓	100.0%	(sqrt.f64 (fabs.f64 (-.f64 x y)))
▶	56.6%	(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))

Compiler

Compiled 36 to 29 computations (19.4% saved)

simplify10.0ms (0.2%)

Memory

-22.2MiB live, 16.7MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 7 expressions of interest:

New	Metric	Score
cost-diff	0	(-.f64 y x)
cost-diff	0	(fabs.f64 (-.f64 y x))
cost-diff	0	(/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
cost-diff	6464	(pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64))
cost-diff	0	#s(approx (- x y) y)
cost-diff	0	(fabs.f64 #s(approx (- x y) y))
cost-diff	0	(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))

Rules

80×	`lower-fma.f64`
80×	`lower-fma.f32`
64×	`lower-*.f64`
64×	`lower-*.f32`
32×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	12	52
0	19	48
1	28	48
2	35	48
3	45	48
4	73	48
5	123	48
6	146	48
7	167	48
8	170	48
9	175	48
10	175	48
0	175	48

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))
(fabs.f64 #s(approx (- x y) y))
#s(approx (- x y) y)
y
(/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64))
(fabs.f64 (-.f64 y x))
(-.f64 y x)
y
x
#s(literal 1 binary64)
(sqrt.f64 (fabs.f64 (-.f64 y x)))

Outputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))
(fabs.f64 #s(approx (- x y) y))
#s(approx (- x y) y)
y
(/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64))
(fabs.f64 (-.f64 y x))
(fabs.f64 (-.f64 y x))
(-.f64 y x)
y
x
#s(literal 1 binary64)
(sqrt.f64 (fabs.f64 (-.f64 y x)))

localize38.0ms (0.8%)

Memory

-1.8MiB live, 115.4MiB allocated

Localize:

Found 7 expressions of interest:

New	Metric	Score
accuracy	0	(-.f64 y x)
accuracy	0	(fabs.f64 (-.f64 y x))
accuracy	0.0078125	(sqrt.f64 (fabs.f64 (-.f64 y x)))
accuracy	0.51171875	(/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
accuracy	0	(fabs.f64 #s(approx (- x y) y))
accuracy	0.0078125	(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))
accuracy	62.699390062706364	#s(approx (- x y) y)

Samples

24.0ms

256×

valid

Compiler

Compiled 48 to 13 computations (72.9% saved)

Precisions

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

ival-fabs: 4.0ms (27.6% of total)

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

ival-sqrt: 3.0ms (20.7% of total)

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

ival-pow: 2.0ms (13.8% of total)

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

exact: 0.0ms (0% of total)

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

series8.0ms (0.2%)

Memory

24.4MiB live, 24.4MiB allocated

Counts

8 → 192

Calls

Call 1

Inputs
#s(alt (sqrt.f64 (fabs.f64 #s(approx (- x y) y))) (patch (sqrt.f64 (fabs.f64 #s(approx (- x y) y))) #<representation binary64>) () ())
#s(alt (fabs.f64 #s(approx (- x y) y)) (patch (fabs.f64 #s(approx (- x y) y)) #<representation binary64>) () ())
#s(alt #s(approx (- x y) y) (patch #s(approx (- x y) y) #<representation binary64>) () ())
#s(alt (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (patch (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) #<representation binary64>) () ())
#s(alt (/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())
#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())
#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())
#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())

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

Calls

6 calls:

Time	Variable		Point	Expression
2.0ms	y	@	inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (pow (fabs (- y x)) 1) (/ (pow (fabs (- y x)) 1) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
1.0ms	y	@	-inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (pow (fabs (- y x)) 1) (/ (pow (fabs (- y x)) 1) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
1.0ms	y	@	0	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (pow (fabs (- y x)) 1) (/ (pow (fabs (- y x)) 1) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
0.0ms	x	@	-inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (pow (fabs (- y x)) 1) (/ (pow (fabs (- y x)) 1) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
0.0ms	x	@	inf	((sqrt (fabs (- x y))) (fabs (- x y)) (- x y) (pow (fabs (- y x)) 1) (/ (pow (fabs (- y x)) 1) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))

simplify163.0ms (3.5%)

Memory

8.2MiB live, 118.8MiB allocated

Algorithm

1×	egg-herbie

Rules

2 626×	`lower-fma.f64`
2 626×	`lower-fma.f32`
2 508×	`lower-*.f64`
2 508×	`lower-*.f32`
1 784×	`div-sub`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	40	774
1	97	774
2	260	774
3	720	774
4	1777	774
5	2465	774
6	3516	774
7	4946	774
8	5438	774
9	5810	774
10	6331	774
11	7004	774
12	7738	774
0	8115	774

Stop Event

1×	iter limit
1×	node limit

Counts

192 → 186

Calls

Call 1

Inputs
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
x
(+ x (* -1 y))
(+ x (* -1 y))
(+ x (* -1 y))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(* -1 x)
(- y x)
(- y x)
(- y x)
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(* -1 y)
(* y (- (/ x y) 1))
(* y (- (/ x y) 1))
(* y (- (/ x y) 1))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
y
(* y (+ 1 (* -1 (/ x y))))
(* y (+ 1 (* -1 (/ x y))))
(* y (+ 1 (* -1 (/ x y))))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(sqrt (fabs (+ x (* -1 y))))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(fabs (+ x (* -1 y)))
(* -1 y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
y
(* -1 (* y (- (/ x y) 1)))
(* -1 (* y (- (/ x y) 1)))
(* -1 (* y (- (/ x y) 1)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(* -1 y)
(- x y)
(- x y)
(- x y)
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
y
(+ y (* -1 x))
(+ y (* -1 x))
(+ y (* -1 x))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(sqrt (fabs (- x y)))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
(fabs (- x y))
x
(* x (+ 1 (* -1 (/ y x))))
(* x (+ 1 (* -1 (/ y x))))
(* x (+ 1 (* -1 (/ y x))))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(* -1 x)
(* x (- (/ y x) 1))
(* x (- (/ y x) 1))
(* x (- (/ y x) 1))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt (fabs (neg (+ y (* -1 x)))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
(fabs (neg (+ y (* -1 x))))
x
(* -1 (* x (- (/ y x) 1)))
(* -1 (* x (- (/ y x) 1)))
(* -1 (* x (- (/ y x) 1)))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(* -1 x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))

Outputs
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
x
(+ x (* -1 y))
(-.f64 x y)
(+ x (* -1 y))
(-.f64 x y)
(+ x (* -1 y))
(-.f64 x y)
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(* -1 x)
(neg.f64 x)
(- y x)
(-.f64 y x)
(- y x)
(-.f64 y x)
(- y x)
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(* -1 y)
(neg.f64 y)
(* y (- (/ x y) 1))
(-.f64 x y)
(* y (- (/ x y) 1))
(-.f64 x y)
(* y (- (/ x y) 1))
(-.f64 x y)
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
y
(* y (+ 1 (* -1 (/ x y))))
(-.f64 y x)
(* y (+ 1 (* -1 (/ x y))))
(-.f64 y x)
(* y (+ 1 (* -1 (/ x y))))
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ x (* -1 y))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(fabs (+ x (* -1 y)))
(fabs.f64 (-.f64 y x))
(* -1 y)
(neg.f64 y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(* -1 (* y (+ 1 (* -1 (/ x y)))))
(-.f64 x y)
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
y
(* -1 (* y (- (/ x y) 1)))
(-.f64 y x)
(* -1 (* y (- (/ x y) 1)))
(-.f64 y x)
(* -1 (* y (- (/ x y) 1)))
(-.f64 y x)
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(* -1 y)
(neg.f64 y)
(- x y)
(-.f64 x y)
(- x y)
(-.f64 x y)
(- x y)
(-.f64 x y)
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
y
(+ y (* -1 x))
(-.f64 y x)
(+ y (* -1 x))
(-.f64 y x)
(+ y (* -1 x))
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
(fabs (- x y))
(fabs.f64 (-.f64 y x))
x
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(* x (+ 1 (* -1 (/ y x))))
(-.f64 x y)
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(* -1 x)
(neg.f64 x)
(* x (- (/ y x) 1))
(-.f64 y x)
(* x (- (/ y x) 1))
(-.f64 y x)
(* x (- (/ y x) 1))
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ y (* -1 x)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ y (* -1 x))))
(fabs.f64 (-.f64 y x))
x
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(* -1 (* x (- (/ y x) 1)))
(-.f64 x y)
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(* -1 x)
(neg.f64 x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(-.f64 y x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(-.f64 y x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(-.f64 y x)
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))

rewrite178.0ms (3.8%)

Memory

7.5MiB live, 131.3MiB allocated

Rules

3 008×	`lower-fma.f64`
3 008×	`lower-fma.f32`
2 828×	`lower-*.f64`
2 828×	`lower-*.f32`
1 798×	`lower-/.f32`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	12	48
0	19	49
1	69	39
2	388	39
3	4208	39
0	8861	39

Stop Event

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

Counts

8 → 590

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))
(fabs.f64 #s(approx (- x y) y))
#s(approx (- x y) y)
(pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64))
(/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(fabs.f64 (-.f64 y x))
(-.f64 y x)
(sqrt.f64 (fabs.f64 (-.f64 y x)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval221.0ms (4.7%)

Memory: -16.4MiB live, 161.9MiB allocated
Compiler: Compiled 20 577 to 2 048 computations (90% saved)

prune160.0ms (3.4%)

Memory

-26.3MiB live, 55.6MiB allocated

Pruning

3 alts after pruning (1 fresh and 2 done)

	Pruned	Kept	Total
New	1 040	1	1 041
Fresh	0	0	0
Picked	1	1	2
Done	1	1	2
Total	1 042	3	1 045

Accuracy

100.0%

Counts

1 045 → 3

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.2%	(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
✓	100.0%	(sqrt.f64 (fabs.f64 (-.f64 x y)))
✓	56.6%	(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))

Compiler

Compiled 19 to 16 computations (15.8% saved)

simplify8.0ms (0.2%)

Memory

6.5MiB live, 6.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(sqrt.f64 (fabs.f64 (-.f64 y x)))
cost-diff	0	(-.f64 y x)
cost-diff	0	(fabs.f64 (-.f64 y x))
cost-diff	0	(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))

Rules

80×	`lower-fma.f64`
80×	`lower-fma.f32`
64×	`lower-*.f64`
64×	`lower-*.f32`
38×	`sub-neg`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	6	24
0	10	24
1	14	24
2	21	24
3	29	24
4	48	24
5	95	24
6	149	24
7	171	24
8	182	24
9	187	24
10	187	24
0	187	24

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(fabs.f64 (-.f64 y x))
(-.f64 y x)
y
x
(sqrt.f64 (fabs.f64 (-.f64 y x)))

Outputs
(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(/.f64 (fabs.f64 (-.f64 x y)) (sqrt.f64 (fabs.f64 (-.f64 x y))))
(fabs.f64 (-.f64 y x))
(fabs.f64 (-.f64 x y))
(-.f64 y x)
y
x
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt.f64 (fabs.f64 (-.f64 x y)))

localize79.0ms (1.7%)

Memory

-11.1MiB live, 26.1MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(-.f64 y x)
accuracy	0	(fabs.f64 (-.f64 y x))
accuracy	0.0078125	(sqrt.f64 (fabs.f64 (-.f64 y x)))
accuracy	0.51171875	(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))

Samples

13.0ms

256×

valid

Compiler

Compiled 26 to 8 computations (69.2% saved)

Precisions

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

ival-sub: 2.0ms (31% of total)

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

ival-sqrt: 2.0ms (31% of total)

ival-fabs: 1.0ms (15.5% of total)

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

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

series3.0ms (0.1%)

Memory

4.9MiB live, 4.9MiB allocated

Counts

4 → 96

Calls

Call 1

Inputs
#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())
#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())
#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())
#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())

Outputs
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor 0 y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (- y x) (taylor 0 y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (- y x) (taylor 0 y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (- y x) (taylor 0 y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ x y)))) (taylor inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ x y)))) (taylor inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (* -1 (/ x y)))) (taylor inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ x (* -1 y)))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ x (* -1 y)))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ x (* -1 y)))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (neg (+ x (* -1 y)))) (taylor -inf y) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ x y) 1))) (taylor -inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ x y) 1))) (taylor -inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (/ x y) 1))) (taylor -inf y) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (neg (+ x (* -1 y))))) (taylor -inf y) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor 0 x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt y (taylor 0 x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 x)) (taylor 0 x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 x)) (taylor 0 x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (+ y (* -1 x)) (taylor 0 x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor 0 x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (- y x)) (taylor inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ y x) 1)) (taylor inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ y x) 1)) (taylor inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* x (- (/ y x) 1)) (taylor inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (- y x))) (taylor inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) (patch (/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x)))) #<representation binary64>) () ())) ())
#s(alt (fabs (+ y (* -1 x))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (+ y (* -1 x))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (+ y (* -1 x))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (fabs (+ y (* -1 x))) (taylor -inf x) (#s(alt (fabs.f64 (-.f64 y x)) (patch (fabs.f64 (-.f64 y x)) #<representation binary64>) () ())) ())
#s(alt (* -1 x) (taylor -inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ y x))))) (taylor -inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ y x))))) (taylor -inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ 1 (* -1 (/ y x))))) (taylor -inf x) (#s(alt (-.f64 y x) (patch (-.f64 y x) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())
#s(alt (sqrt (fabs (+ y (* -1 x)))) (taylor -inf x) (#s(alt (sqrt.f64 (fabs.f64 (-.f64 y x))) (patch (sqrt.f64 (fabs.f64 (-.f64 y x))) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
0.0ms	x	@	-inf	((/ (fabs (- y x)) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
0.0ms	y	@	inf	((/ (fabs (- y x)) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
0.0ms	y	@	-inf	((/ (fabs (- y x)) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
0.0ms	x	@	inf	((/ (fabs (- y x)) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))
0.0ms	y	@	0	((/ (fabs (- y x)) (sqrt (fabs (- y x)))) (fabs (- y x)) (- y x) (sqrt (fabs (- y x))))

simplify229.0ms (4.8%)

Memory

34.4MiB live, 107.9MiB allocated

Algorithm

1×	egg-herbie

Rules

2 658×	`lower-fma.f64`
2 658×	`lower-fma.f32`
2 540×	`lower-*.f64`
2 540×	`lower-*.f32`
1 964×	`div-sub`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	30	399
1	79	399
2	186	399
3	544	399
4	1591	399
5	2431	399
6	3312	399
7	4897	399
8	5404	399
9	5780	399
10	6301	399
11	6955	399
12	7691	399
0	8068	399

Stop Event

1×	iter limit
1×	node limit

Counts

96 → 93

Calls

Call 1

Inputs
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(* -1 x)
(- y x)
(- y x)
(- y x)
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
y
(* y (+ 1 (* -1 (/ x y))))
(* y (+ 1 (* -1 (/ x y))))
(* y (+ 1 (* -1 (/ x y))))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
(fabs (neg (+ x (* -1 y))))
y
(* -1 (* y (- (/ x y) 1)))
(* -1 (* y (- (/ x y) 1)))
(* -1 (* y (- (/ x y) 1)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
y
(+ y (* -1 x))
(+ y (* -1 x))
(+ y (* -1 x))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(fabs (- y x))
(* -1 x)
(* x (- (/ y x) 1))
(* x (- (/ y x) 1))
(* x (- (/ y x) 1))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (- y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(fabs (+ y (* -1 x)))
(* -1 x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))
(sqrt (fabs (+ y (* -1 x))))

Outputs
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(* -1 x)
(neg.f64 x)
(- y x)
(-.f64 y x)
(- y x)
(-.f64 y x)
(- y x)
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
y
(* y (+ 1 (* -1 (/ x y))))
(-.f64 y x)
(* y (+ 1 (* -1 (/ x y))))
(-.f64 y x)
(* y (+ 1 (* -1 (/ x y))))
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
(fabs (neg (+ x (* -1 y))))
(fabs.f64 (-.f64 y x))
y
(* -1 (* y (- (/ x y) 1)))
(-.f64 y x)
(* -1 (* y (- (/ x y) 1)))
(-.f64 y x)
(* -1 (* y (- (/ x y) 1)))
(-.f64 y x)
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (neg (+ x (* -1 y)))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
y
(+ y (* -1 x))
(-.f64 y x)
(+ y (* -1 x))
(-.f64 y x)
(+ y (* -1 x))
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(fabs (- y x))
(fabs.f64 (-.f64 y x))
(* -1 x)
(neg.f64 x)
(* x (- (/ y x) 1))
(-.f64 y x)
(* x (- (/ y x) 1))
(-.f64 y x)
(* x (- (/ y x) 1))
(-.f64 y x)
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (- y x)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(fabs (+ y (* -1 x)))
(fabs.f64 (-.f64 y x))
(* -1 x)
(neg.f64 x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(-.f64 y x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(-.f64 y x)
(* -1 (* x (+ 1 (* -1 (/ y x)))))
(-.f64 y x)
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt (fabs (+ y (* -1 x))))
(sqrt.f64 (fabs.f64 (-.f64 y x)))

rewrite168.0ms (3.5%)

Memory

-45.2MiB live, 321.5MiB allocated

Rules

4 446×	`lower-fma.f64`
4 446×	`lower-fma.f32`
3 738×	`lower-/.f32`
3 736×	`lower-/.f64`
3 268×	`lower-*.f64`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	6	22
0	10	27
1	39	27
2	226	17
3	1974	17
0	8415	17

Stop Event

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

Counts

4 → 481

Calls

Call 1

Inputs
(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(fabs.f64 (-.f64 y x))
(-.f64 y x)
(sqrt.f64 (fabs.f64 (-.f64 y x)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval212.0ms (4.5%)

Memory: 31.4MiB live, 292.0MiB allocated
Compiler: Compiled 22 697 to 2 123 computations (90.6% saved)

prune20.0ms (0.4%)

Memory

-10.0MiB live, 76.8MiB allocated

Pruning

3 alts after pruning (0 fresh and 3 done)

	Pruned	Kept	Total
New	886	0	886
Fresh	0	0	0
Picked	0	1	1
Done	0	2	2
Total	886	3	889

Accuracy

100.0%

Counts

889 → 3

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.2%	(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
✓	100.0%	(sqrt.f64 (fabs.f64 (-.f64 x y)))
✓	56.6%	(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))

Compiler

Compiled 70 to 43 computations (38.6% saved)

regimes14.0ms (0.3%)

Memory

9.0MiB live, 48.1MiB allocated

Counts

6 → 1

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))
(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(/.f64 (fabs.f64 (-.f64 y x)) (sqrt.f64 (fabs.f64 (-.f64 y x))))
(/.f64 (sqrt.f64 (fabs.f64 (fma.f64 (neg.f64 y) y (*.f64 x x)))) (sqrt.f64 (fabs.f64 (+.f64 y x))))
(/.f64 (pow.f64 (fabs.f64 (-.f64 y x)) #s(literal 1 binary64)) (sqrt.f64 (fabs.f64 (-.f64 y x))))

Outputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))

Calls

5 calls:

3.0ms	y
3.0ms	x
3.0ms	(-.f64 x y)
3.0ms	(sqrt.f64 (fabs.f64 (-.f64 x y)))
3.0ms	(fabs.f64 (-.f64 x y))

Results

Accuracy	Segments	Branch
100.0%	1	`x`
100.0%	1	`y`
100.0%	1	`(sqrt.f64 (fabs.f64 (-.f64 x y)))`
100.0%	1	`(fabs.f64 (-.f64 x y))`
100.0%	1	`(-.f64 x y)`

Compiler

Compiled 14 to 16 computations (-14.3% saved)

regimes43.0ms (0.9%)

Memory

-11.7MiB live, 27.5MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

2 → 1

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))
(sqrt.f64 (fabs.f64 #s(approx (- x y) (neg.f64 y))))

Outputs
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))

Calls

5 calls:

37.0ms	x
2.0ms	(sqrt.f64 (fabs.f64 (-.f64 x y)))
1.0ms	(fabs.f64 (-.f64 x y))
1.0ms	(-.f64 x y)
1.0ms	y

Results

Accuracy	Segments	Branch
56.6%	1	`x`
56.6%	1	`y`
56.6%	1	`(sqrt.f64 (fabs.f64 (-.f64 x y)))`
56.6%	1	`(fabs.f64 (-.f64 x y))`
56.6%	1	`(-.f64 x y)`

Compiler

Compiled 14 to 16 computations (-14.3% saved)

simplify43.0ms (0.9%)

Memory

21.7MiB live, 62.6MiB allocated

Algorithm

1×	egg-herbie

Rules

8×	`+-commutative-binary64-+.f64`
8×	`sub-neg-binary64-neg.f64-+.f64--.f64`
4×	`-commutative-binary64-.f64`
4×	`neg-sub0-binary64--.f64-neg.f64`
4×	`neg-mul-1-binary64-*.f64-neg.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	9	12
1	13	12
2	20	12
3	25	12
4	28	12
5	29	12

Stop Event

1×

saturated

Calls

Call 1

Inputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))

Outputs
(sqrt.f64 (fabs.f64 (-.f64 x y)))
(sqrt.f64 (fabs.f64 (-.f64 y x)))
(sqrt.f64 (fabs.f64 #s(approx (- x y) y)))

soundness374.0ms (7.9%)

Memory

-35.9MiB live, 215.9MiB allocated

Rules

4 246×	`lower-fma.f32`
4 244×	`lower-fma.f64`
3 020×	`lower-*.f32`
3 018×	`lower-*.f64`
2 658×	`lower-fma.f64`

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	15	67
0	27	75
1	90	57
2	543	57
3	5733	46
0	9520	46
0	30	279
1	79	279
2	186	279
3	541	279
4	1596	279
5	2435	279
6	3316	279
7	4901	279
8	5409	279
9	5785	279
10	6306	279
11	6970	279
12	7705	279
0	8082	279

Stop Event

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

Compiler

Compiled 18 to 19 computations (-5.6% saved)

preprocess24.0ms (0.5%)

Memory: 29.5MiB live, 67.3MiB allocated
Remove: (sort x y)
Compiler: Compiled 48 to 46 computations (4.2% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

Iter	Nodes	Cost
0	15	31
1	35	27
2	72	27
3	137	27
4	185	27
5	197	27
6	199	27
0	5	5
0	8	5
1	12	5
2	19	5
3	27	5
4	46	5
5	93	5
6	144	5
7	165	5
8	173	5
0	173	5

Iter	Nodes	Cost
0	12	52
0	19	48
1	28	48
2	35	48
3	45	48
4	73	48
5	123	48
6	146	48
7	167	48
8	170	48
9	175	48
10	175	48
0	175	48

Iter	Nodes	Cost
0	6	24
0	10	24
1	14	24
2	21	24
3	29	24
4	48	24
5	95	24
6	149	24
7	171	24
8	182	24
9	187	24
10	187	24
0	187	24

Iter	Nodes	Cost
0	15	31
1	35	27
2	72	27
3	137	27
4	185	27
5	197	27
6	199	27
0	5	5
0	8	5
1	12	5
2	19	5
3	27	5
4	46	5
5	93	5
6	144	5
7	165	5
8	173	5
0	173	5

Iter	Nodes	Cost
0	12	52
0	19	48
1	28	48
2	35	48
3	45	48
4	73	48
5	123	48
6	146	48
7	167	48
8	170	48
9	175	48
10	175	48
0	175	48

Iter	Nodes	Cost
0	6	24
0	10	24
1	14	24
2	21	24
3	29	24
4	48	24
5	95	24
6	149	24
7	171	24
8	182	24
9	187	24
10	187	24
0	187	24

start0.0ms (0%)

analyze0.0ms (0%)

sample811.0ms (17.2%)

explain108.0ms (2.3%)

preprocess37.0ms (0.8%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify9.0ms (0.2%)

localize17.0ms (0.4%)

series4.0ms (0.1%)

simplify232.0ms (4.9%)

rewrite163.0ms (3.4%)

eval155.0ms (3.3%)

prune11.0ms (0.2%)

simplify673.0ms (14.2%)

localize50.0ms (1.1%)

series17.0ms (0.4%)

simplify185.0ms (3.9%)

rewrite132.0ms (2.8%)

eval107.0ms (2.3%)

prune21.0ms (0.4%)

simplify10.0ms (0.2%)

localize38.0ms (0.8%)

series8.0ms (0.2%)

simplify163.0ms (3.5%)

rewrite178.0ms (3.8%)

eval221.0ms (4.7%)

prune160.0ms (3.4%)

simplify8.0ms (0.2%)

localize79.0ms (1.7%)

series3.0ms (0.1%)

simplify229.0ms (4.8%)

rewrite168.0ms (3.5%)

eval212.0ms (4.5%)

prune20.0ms (0.4%)

regimes14.0ms (0.3%)

regimes43.0ms (0.9%)

simplify43.0ms (0.9%)

soundness374.0ms (7.9%)

preprocess24.0ms (0.5%)

end0.0ms (0%)

Profiling

Iter	Nodes	Cost
0	15	31
1	35	27
2	72	27
3	137	27
4	185	27
5	197	27
6	199	27
0	5	5
0	8	5
1	12	5
2	19	5
3	27	5
4	46	5
5	93	5
6	144	5
7	165	5
8	173	5
0	173	5

Iter	Nodes	Cost
0	12	52
0	19	48
1	28	48
2	35	48
3	45	48
4	73	48
5	123	48
6	146	48
7	167	48
8	170	48
9	175	48
10	175	48
0	175	48

Iter	Nodes	Cost
0	6	24
0	10	24
1	14	24
2	21	24
3	29	24
4	48	24
5	95	24
6	149	24
7	171	24
8	182	24
9	187	24
10	187	24
0	187	24