Metrics for Numeric.SpecFunctions:logBeta from math-functions-0.1.5.2, A

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze3.0ms (0.1%)

Memory

4.3MiB live, 4.3MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.7%	0.3%	0%	0%	0%	0
0%	0%	99.7%	0.3%	0%	0%	0%	1
0%	0%	99.7%	0.3%	0%	0%	0%	2
0%	0%	99.7%	0.3%	0%	0%	0%	3
0%	0%	99.7%	0.3%	0%	0%	0%	4
100%	49.9%	0%	0.3%	0%	49.9%	0%	5

Compiler

Compiled 18 to 17 computations (5.6% saved)

sample1.2s (50.8%)

Memory

-77.8MiB live, 1 392.6MiB allocated

Samples

709.0ms	8 251×	0	valid
1.0ms	4×	1	valid
0.0ms	1×	2	valid

Precisions

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

ival-add: 119.0ms (27.2% of total)

ival-log: 108.0ms (24.7% of total)

ival-mult: 107.0ms (24.4% of total)

ival-sub: 91.0ms (20.8% of total)

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

exact: 4.0ms (0.9% of total)

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

adjust: 0.0ms (0% of total)

Bogosity

explain142.0ms (6%)

Memory

29.9MiB live, 226.8MiB allocated

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
-	-	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
-	-	`(log.f64 t)`
-	-	`a`
-	-	`t`
-	-	`z`
-	-	`(+.f64 (+.f64 x y) z)`
-	-	`y`
-	-	`(*.f64 z (log.f64 t))`
-	-	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
-	-	`(+.f64 x y)`
-	-	`b`
-	-	`#s(literal 1/2 binary64)`
-	-	`x`
-	-	`(-.f64 a #s(literal 1/2 binary64))`

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

49.0ms

512×

valid

Compiler

Compiled 185 to 64 computations (65.4% saved)

Precisions

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

ival-log: 8.0ms (29.9% of total)

ival-add: 7.0ms (26.2% of total)

ival-mult: 7.0ms (26.2% of total)

ival-sub: 5.0ms (18.7% of total)

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

exact: 0.0ms (0% of total)

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

preprocess16.0ms (0.7%)

Memory

-35.3MiB live, 10.5MiB allocated

Algorithm

1×	egg-herbie

Calls

Call 1

Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Compiler

Compiled 16 to 15 computations (6.3% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.9%	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Compiler

Compiled 16 to 15 computations (6.3% saved)

simplify0.0ms (0%)

Memory

1.1MiB live, 1.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	0	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
cost-diff	0	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Calls

Call 1

Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b

localize36.0ms (1.5%)

Memory

20.0MiB live, 56.1MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.0	(log.f64 t)
accuracy	0.00390625	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0703125	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
accuracy	0.27734375	(*.f64 z (log.f64 t))

Samples

28.0ms

256×

valid

Compiler

Compiled 112 to 32 computations (71.4% saved)

Precisions

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

ival-add: 8.0ms (47.8% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

series119.0ms (5%)

Memory

-0.8MiB live, 192.1MiB allocated

Counts

6 → 58

Calls

Call 1

Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(*.f64 z (log.f64 t))
(log.f64 t)

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (log t))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(log t)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (* z (log (/ 1 t))))
(* -1 (log (/ 1 t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(+ (log -1) (* -1 (log (/ -1 t))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Calls

18 calls:

Time	Variable		Point	Expression
35.0ms	z	@	0	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (* z (log t)) (log t))
13.0ms	z	@	inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (* z (log t)) (log t))
12.0ms	t	@	-inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (* z (log t)) (log t))
11.0ms	t	@	0	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (* z (log t)) (log t))
10.0ms	t	@	inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (* z (log t)) (log t))

simplify1.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated

Algorithm

1×	egg-herbie

Counts

58 → 6

Calls

Call 1

Inputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (log t))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(log t)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (* z (log (/ 1 t))))
(* -1 (log (/ 1 t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(+ (log -1) (* -1 (log (/ -1 t))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(- (+ y z) (* z (log t)))
(+.f64 (+.f64 x y) z)
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x y)
(+ y z)
(*.f64 z (log.f64 t))
(+ x (+ y z))
(log.f64 t)

rewrite0.0ms (0%)

Memory

0.8MiB live, 0.8MiB allocated

Counts

6 → 6

Calls

Call 1

Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(*.f64 z (log.f64 t))
(log.f64 t)

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(*.f64 z (log.f64 t))
(log.f64 t)

eval1.0ms (0.1%)

Memory: 3.2MiB live, 3.2MiB allocated
Compiler: Compiled 238 to 36 computations (84.9% saved)

prune2.0ms (0.1%)

Memory

3.7MiB live, 3.7MiB allocated

Pruning

4 alts after pruning (3 fresh and 1 done)

	Pruned	Kept	Total
New	9	3	12
Fresh	0	0	0
Picked	0	1	1
Done	0	0	0
Total	9	4	13

Accuracy

99.9%

Counts

13 → 4

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.9%	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	80.1%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	79.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	63.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))

Compiler

Compiled 85 to 71 computations (16.5% saved)

simplify1.0ms (0%)

Memory

1.6MiB live, 1.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 12 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
cost-diff	0	(+.f64 x y)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	0	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b

localize47.0ms (2%)

Memory

6.6MiB live, 86.2MiB allocated

Localize:

Found 12 expressions of interest:

New	Metric	Score
accuracy	0.0	(+.f64 x y)
accuracy	0.0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	0.00390625	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	19.90495191222517	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
accuracy	0.0	(+.f64 x y)
accuracy	0.0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	0.00390625	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	20.629693469931524	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
accuracy	0.0	(log.f64 t)
accuracy	0.0703125	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
accuracy	0.27734375	(*.f64 z (log.f64 t))
accuracy	23.11790398735755	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))

Samples

35.0ms

256×

valid

Compiler

Compiled 301 to 45 computations (85% saved)

Precisions

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

ival-log: 9.0ms (50% of total)

ival-add: 4.0ms (22.2% of total)

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

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

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

exact: 0.0ms (0% of total)

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

series74.0ms (3.1%)

Memory

4.4MiB live, 158.4MiB allocated

Counts

11 → 62

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(*.f64 z (log.f64 t))
(log.f64 t)

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (log t))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(log t)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (* z (log (/ 1 t))))
(* -1 (log (/ 1 t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(+ (log -1) (* -1 (log (/ -1 t))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (+ b (* -1/2 (/ b a))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Calls

18 calls:

Time	Variable		Point	Expression
12.0ms	t	@	-inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* z (log t)) (log t))
9.0ms	z	@	0	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* z (log t)) (log t))
8.0ms	t	@	0	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* z (log t)) (log t))
8.0ms	z	@	inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* z (log t)) (log t))
7.0ms	t	@	inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* z (log t)) (log t))

simplify1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated

Algorithm

1×	egg-herbie

Counts

62 → 11

Calls

Call 1

Inputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (log t))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(log t)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (* z (log (/ 1 t))))
(* -1 (log (/ 1 t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(+ (log -1) (* -1 (log (/ -1 t))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (+ b (* -1/2 (/ b a))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(- (+ y z) (* z (log t)))
(+.f64 (+.f64 x y) z)
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x y)
(+ y z)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+ x (+ y z))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
y
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+ x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
x
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 z (log.f64 t))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(log.f64 t)

rewrite1.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated

Counts

11 → 11

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(*.f64 z (log.f64 t))
(log.f64 t)

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(*.f64 z (log.f64 t))
(log.f64 t)

eval7.0ms (0.3%)

Memory: -29.0MiB live, 7.0MiB allocated
Compiler: Compiled 897 to 60 computations (93.3% saved)

prune7.0ms (0.3%)

Memory

16.6MiB live, 16.6MiB allocated

Pruning

11 alts after pruning (8 fresh and 3 done)

	Pruned	Kept	Total
New	21	8	29
Fresh	0	0	0
Picked	0	3	3
Done	1	0	1
Total	22	11	33

Accuracy

99.9%

Counts

33 → 11

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	80.1%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	57.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	16.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	79.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	15.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	63.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
▶	57.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
▶	49.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
	44.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
▶	43.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
	2.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))

Compiler

Compiled 605 to 372 computations (38.5% saved)

simplify2.0ms (0.1%)

Memory

3.6MiB live, 3.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

New	Metric	Score	Program
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
cost-diff	0	#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
cost-diff	0	(-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t)))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
cost-diff	0	#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
cost-diff	0	(+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
cost-diff	0	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(+.f64 x y)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
cost-diff	0	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
cost-diff	0	(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
(+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
(-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t)))
#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
(*.f64 z (log.f64 t))
z
(log.f64 t)
t

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
(+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
(-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t)))
#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
(*.f64 z (log.f64 t))
z
(log.f64 t)
t

localize70.0ms (2.9%)

Memory

3.1MiB live, 132.2MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score
accuracy	0.27734375	(*.f64 z (log.f64 t))
accuracy	19.90495191222517	#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
accuracy	20.629693469931524	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
accuracy	23.11790398735755	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
accuracy	0.00390625	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	19.90495191222517	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
accuracy	19.90495191222517	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
accuracy	36.29383692861245	#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
accuracy	0.0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	0.00390625	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	20.629693469931524	#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
accuracy	62.144215681981464	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0	(+.f64 x y)
accuracy	20.629693469931524	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
accuracy	23.11790398735755	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
accuracy	0.0703125	(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
accuracy	0.27734375	(*.f64 z (log.f64 t))
accuracy	23.11790398735755	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
accuracy	62.144215681981464	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Samples

51.0ms

256×

valid

Compiler

Compiled 778 to 56 computations (92.8% saved)

Precisions

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

ival-sub: 6.0ms (35.9% of total)

ival-add: 4.0ms (23.9% of total)

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

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

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

exact: 0.0ms (0% of total)

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

series88.0ms (3.7%)

Memory

5.8MiB live, 163.6MiB allocated

Counts

19 → 59

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
(+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
(-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t)))
#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(*.f64 z (log.f64 t))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (log t))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (* z (log (/ 1 t))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (+ b (* -1/2 (/ b a))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Calls

18 calls:

Time	Variable		Point	Expression
15.0ms	z	@	0	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (* z (log t)) (- (+ (+ x y) z) (* z (log t))))
13.0ms	t	@	0	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (* z (log t)) (- (+ (+ x y) z) (* z (log t))))
12.0ms	t	@	-inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (* z (log t)) (- (+ (+ x y) z) (* z (log t))))
7.0ms	t	@	inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (* z (log t)) (- (+ (+ x y) z) (* z (log t))))
7.0ms	z	@	-inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (* z (log t)) (- (+ (+ x y) z) (* z (log t))))

simplify1.0ms (0%)

Memory

2.2MiB live, 2.2MiB allocated

Algorithm

1×	egg-herbie

Counts

59 → 19

Calls

Call 1

Inputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (log t))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (* z (log (/ 1 t))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (+ b (* -1/2 (/ b a))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
(- (+ y z) (* z (log t)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
(- (+ x (+ y z)) (* z (log t)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+ y z)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+ x (+ y z))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
y
(+.f64 x y)
(+ x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
x
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(* x (+ 1 (+ (/ y x) (/ z x))))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
(* x (+ 1 (/ y x)))
(+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(*.f64 z (log.f64 t))
(- (+ x z) (* z (log t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))

rewrite6.0ms (0.2%)

Memory

-35.1MiB live, 2.7MiB allocated

Counts

19 → 19

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
(+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
(-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t)))
#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(*.f64 z (log.f64 t))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))
(+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
(-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t)))
#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(*.f64 z (log.f64 t))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))

eval5.0ms (0.2%)

Memory: 12.2MiB live, 12.2MiB allocated
Compiler: Compiled 1 972 to 85 computations (95.7% saved)

prune8.0ms (0.3%)

Memory

20.0MiB live, 20.0MiB allocated

Pruning

12 alts after pruning (5 fresh and 7 done)

	Pruned	Kept	Total
New	45	3	48
Fresh	1	2	3
Picked	0	5	5
Done	1	2	3
Total	47	12	59

Accuracy

99.9%

Counts

59 → 12

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	57.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	79.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	15.5%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	15.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	63.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
✓	57.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
✓	49.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
▶	37.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	44.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
▶	38.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
✓	43.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
▶	2.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))

Compiler

Compiled 566 to 337 computations (40.5% saved)

simplify1.0ms (0.1%)

Memory

3.3MiB live, 3.3MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 18 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(log.f64 t)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
cost-diff	0	(-.f64 a #s(literal 1/2 binary64))
cost-diff	0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
z
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
(log.f64 t)
t

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
z
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
(log.f64 t)
t

localize55.0ms (2.3%)

Memory

-30.9MiB live, 90.3MiB allocated

Localize:

Found 18 expressions of interest:

New	Metric	Score
accuracy	0.0	(log.f64 t)
accuracy	23.11790398735755	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
accuracy	62.06507127893485	#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
accuracy	20.629693469931524	#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
accuracy	20.629693469931524	#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
accuracy	36.29383692861245	#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
accuracy	62.144215681981464	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	19.90495191222517	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
accuracy	23.11790398735755	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
accuracy	62.144215681981464	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0	(-.f64 a #s(literal 1/2 binary64))
accuracy	0.0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	39.82256993422576	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0	(+.f64 (+.f64 x y) z)
accuracy	0.0	(+.f64 x y)
accuracy	19.90495191222517	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
accuracy	23.11790398735755	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))

Samples

37.0ms

256×

valid

Compiler

Compiled 626 to 52 computations (91.7% saved)

Precisions

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

ival-add: 4.0ms (31.1% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

series53.0ms (2.2%)

Memory

24.3MiB live, 101.1MiB allocated

Counts

19 → 64

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
(log.f64 t)
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(log t)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (log (/ 1 t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+ (log -1) (* -1 (log (/ -1 t))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
-1/2
(- a 1/2)
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (+ b (* -1/2 (/ b a))))
a
(* a (- 1 (* 1/2 (/ 1 a))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Calls

18 calls:

Time	Variable		Point	Expression
10.0ms	t	@	-inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* (- a 1/2) b) (- a 1/2) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (log t) (- (+ (+ x y) z) (* z (log t))))
7.0ms	t	@	inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* (- a 1/2) b) (- a 1/2) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (log t) (- (+ (+ x y) z) (* z (log t))))
7.0ms	t	@	0	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* (- a 1/2) b) (- a 1/2) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (log t) (- (+ (+ x y) z) (* z (log t))))
5.0ms	z	@	inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* (- a 1/2) b) (- a 1/2) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (log t) (- (+ (+ x y) z) (* z (log t))))
2.0ms	z	@	-inf	((+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* (- a 1/2) b) (- a 1/2) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (log t) (- (+ (+ x y) z) (* z (log t))))

simplify1.0ms (0%)

Memory

1.7MiB live, 1.7MiB allocated

Algorithm

1×	egg-herbie

Counts

64 → 19

Calls

Call 1

Inputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(+ y z)
(+ x (+ y z))
y
(+ x y)
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (/ y x)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x z) (* z (log t)))
(+ x z)
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (/ x y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(log t)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(* -1 (log (/ 1 t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+ (log -1) (* -1 (log (/ -1 t))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
-1/2
(- a 1/2)
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (+ b (* -1/2 (/ b a))))
a
(* a (- 1 (* 1/2 (/ 1 a))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))

Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(- (+ y z) (* z (log t)))
(+.f64 (+.f64 x y) z)
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x y)
(+ y z)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+ x (+ y z))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
y
(-.f64 a #s(literal 1/2 binary64))
(+ x y)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
x
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(* x (+ 1 (/ y x)))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(log.f64 t)
(- (+ x z) (* z (log t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))

rewrite1.0ms (0%)

Memory

2.1MiB live, 2.1MiB allocated

Counts

19 → 19

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
(log.f64 t)
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
#s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
(log.f64 t)
#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))

eval6.0ms (0.3%)

Memory: -27.8MiB live, 10.6MiB allocated
Compiler: Compiled 1 825 to 74 computations (95.9% saved)

prune10.0ms (0.4%)

Memory

27.6MiB live, 27.6MiB allocated

Pruning

15 alts after pruning (3 fresh and 12 done)

	Pruned	Kept	Total
New	40	3	43
Fresh	0	0	0
Picked	0	5	5
Done	0	7	7
Total	40	15	55

Accuracy

99.9%

Counts

55 → 15

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	57.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	79.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	15.5%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	15.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	63.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
✓	57.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
✓	49.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
✓	37.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	44.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
	4.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
✓	38.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
	3.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))) z)))
	38.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))
✓	43.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
✓	2.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))

Compiler

Compiled 1 170 to 372 computations (68.2% saved)

regimes82.0ms (3.4%)

Memory

-28.6MiB live, 180.4MiB allocated

Counts

18 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Calls

12 calls:

8.0ms	x
8.0ms	t
8.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
7.0ms	(-.f64 a #s(literal 1/2 binary64))
7.0ms	(log.f64 t)

Results

Accuracy	Segments	Branch
99.9%	1	`x`
99.9%	1	`y`
99.9%	1	`z`
99.9%	1	`t`
99.9%	1	`a`
99.9%	1	`b`
99.9%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
99.9%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
99.9%	1	`(+.f64 x y)`
99.9%	1	`(log.f64 t)`
99.9%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
99.9%	1	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes71.0ms (3%)

Memory

30.6MiB live, 147.2MiB allocated

Counts

17 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t))))

Outputs

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Calls

12 calls:

7.0ms	(log.f64 t)
7.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
6.0ms	z
6.0ms	(+.f64 x y)
6.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))

Results

Accuracy	Segments	Branch
80.1%	1	`x`
85.2%	3	`y`
91.9%	3	`z`
80.1%	1	`t`
82.0%	2	`a`
90.5%	3	`b`
80.1%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
85.5%	3	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
89.3%	3	`(+.f64 x y)`
80.1%	1	`(log.f64 t)`
92.6%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
82.0%	2	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes56.0ms (2.3%)

Memory

-9.7MiB live, 108.3MiB allocated

Counts

15 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 #s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 z (log.f64 t))))

Outputs
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Calls

10 calls:

7.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
6.0ms	(+.f64 x y)
6.0ms	a
5.0ms	y
5.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))

Results

Accuracy	Segments	Branch
80.1%	1	`t`
80.1%	1	`(log.f64 t)`
80.1%	1	`a`
80.1%	1	`(-.f64 a #s(literal 1/2 binary64))`
80.1%	1	`y`
80.1%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
80.1%	1	`(+.f64 x y)`
80.1%	1	`b`
80.1%	1	`z`
80.1%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 28 to 72 computations (-157.1% saved)

regimes41.0ms (1.7%)

Memory

-7.4MiB live, 73.1MiB allocated

Counts

7 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Outputs
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Calls

12 calls:

7.0ms	x
4.0ms	b
3.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
3.0ms	(+.f64 x y)
3.0ms	y

Results

Accuracy	Segments	Branch
79.3%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
79.3%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
79.3%	1	`x`
79.3%	1	`y`
79.3%	1	`z`
79.3%	1	`(+.f64 x y)`
79.3%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
79.3%	1	`t`
79.3%	1	`a`
79.3%	1	`b`
79.3%	1	`(log.f64 t)`
79.3%	1	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes34.0ms (1.4%)

Memory

-13.1MiB live, 64.2MiB allocated

Counts

6 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))

Calls

12 calls:

4.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
3.0ms	a
3.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
3.0ms	(+.f64 x y)
3.0ms	y

Results

Accuracy	Segments	Branch
56.5%	3	`a`
53.4%	3	`x`
56.5%	3	`(-.f64 a #s(literal 1/2 binary64))`
70.4%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
56.3%	3	`y`
48.6%	2	`t`
65.4%	3	`b`
53.3%	3	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
59.1%	3	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
61.2%	3	`(+.f64 x y)`
48.6%	2	`(log.f64 t)`
49.6%	3	`z`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes3.0ms (0.1%)

Memory

5.7MiB live, 5.7MiB allocated

Counts

5 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))

Calls

1 calls:

2.0ms

(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

Results

Accuracy	Segments	Branch
70.4%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 5 to 9 computations (-80% saved)

regimes2.0ms (0.1%)

Memory

5.3MiB live, 5.3MiB allocated

Counts

4 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Calls

1 calls:

2.0ms

(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

Results

Accuracy	Segments	Branch
70.2%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 5 to 9 computations (-80% saved)

regimes24.0ms (1%)

Memory

18.5MiB live, 57.3MiB allocated

Counts

3 → 1

Calls

Call 1

Inputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))

Calls

12 calls:

2.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
2.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
2.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
2.0ms	b
2.0ms	y

Results

Accuracy	Segments	Branch
44.3%	1	`z`
44.3%	1	`t`
44.3%	1	`(log.f64 t)`
44.3%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
44.3%	1	`x`
44.3%	1	`y`
44.3%	1	`(-.f64 a #s(literal 1/2 binary64))`
44.3%	1	`a`
44.3%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
44.3%	1	`(+.f64 x y)`
44.3%	1	`b`
44.3%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes21.0ms (0.9%)

Memory

4.6MiB live, 46.0MiB allocated

Accuracy

Total -26.1b remaining (-72%)

Threshold costs -26.1b (-72%)

Counts

2 → 1

Calls

Call 1

Inputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (-.f64 a #s(literal 1/2 binary64))) z)))

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

Calls

12 calls:

4.0ms	y
2.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
1.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
1.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
1.0ms	a

Results

Accuracy	Segments	Branch
43.3%	1	`z`
43.3%	1	`t`
43.3%	1	`b`
43.3%	1	`(log.f64 t)`
43.3%	1	`x`
43.3%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
43.3%	1	`a`
43.3%	1	`(+.f64 x y)`
43.3%	1	`(-.f64 a #s(literal 1/2 binary64))`
43.3%	1	`y`
43.3%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
43.3%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

bsearch1.0ms (0%)

Memory

1.4MiB live, 1.4MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.3026289863698012e+125	2.333016772153009e+133
0.0ms	-7.809347520030453e+96	-9.217236861824285e+95

Compiler

Compiled 19 to 24 computations (-26.3% saved)

bsearch1.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.5565226736142926e+144	9.480519233917778e+145
0.0ms	-7.809347520030453e+96	-9.217236861824285e+95

Compiler

Compiled 19 to 24 computations (-26.3% saved)

bsearch2.0ms (0.1%)

Memory

-37.3MiB live, 1.4MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.5565226736142926e+144	9.480519233917778e+145
1.0ms	-7.809347520030453e+96	-9.217236861824285e+95

Compiler

Compiled 19 to 24 computations (-26.3% saved)

bsearch1.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.5565226736142926e+144	9.480519233917778e+145
0.0ms	-7.809347520030453e+96	-9.217236861824285e+95

Compiler

Compiled 19 to 24 computations (-26.3% saved)

simplify6.0ms (0.3%)

Memory

13.3MiB live, 13.3MiB allocated

Algorithm

1×	egg-herbie

Calls

Call 1

Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 199999999999999984973552323798576408508934173966967692287845194445058839995158605320632698752563530750306011682731106456567808 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t)))) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 2000000000000000047490864717302210714817315855657364374946929977340474859084041145136355256432166588258691938267680232151586826339780163146874880 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 2000000000000000047490864717302210714817315855657364374946929977340474859084041145136355256432166588258691938267680232151586826339780163146874880 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 2000000000000000047490864717302210714817315855657364374946929977340474859084041145136355256432166588258691938267680232151586826339780163146874880 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 199999999999999984973552323798576408508934173966967692287845194445058839995158605320632698752563530750306011682731106456567808 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t)))) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 2000000000000000047490864717302210714817315855657364374946929977340474859084041145136355256432166588258691938267680232151586826339780163146874880 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))) z)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 2000000000000000047490864717302210714817315855657364374946929977340474859084041145136355256432166588258691938267680232151586826339780163146874880 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -5000000000000000367879369238556249198788031076088728399622928950675879571901095101025339828076544 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 2000000000000000047490864717302210714817315855657364374946929977340474859084041145136355256432166588258691938267680232151586826339780163146874880 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

soundness2.0ms (0.1%)

Memory

5.2MiB live, 5.2MiB allocated

Stop Event

1×

fuel

Compiler

Compiled 624 to 54 computations (91.3% saved)

preprocess57.0ms (2.4%)

Memory: -1.3MiB live, 117.5MiB allocated
Compiler: Compiled 1 326 to 178 computations (86.6% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze3.0ms (0.1%)

sample1.2s (50.8%)

explain142.0ms (6%)

preprocess16.0ms (0.7%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify0.0ms (0%)

localize36.0ms (1.5%)

series119.0ms (5%)

simplify1.0ms (0%)

rewrite0.0ms (0%)

eval1.0ms (0.1%)

prune2.0ms (0.1%)

simplify1.0ms (0%)

localize47.0ms (2%)

series74.0ms (3.1%)

simplify1.0ms (0%)

rewrite1.0ms (0%)

eval7.0ms (0.3%)

prune7.0ms (0.3%)

simplify2.0ms (0.1%)

localize70.0ms (2.9%)

series88.0ms (3.7%)

simplify1.0ms (0%)

rewrite6.0ms (0.2%)

eval5.0ms (0.2%)

prune8.0ms (0.3%)

simplify1.0ms (0.1%)

localize55.0ms (2.3%)

series53.0ms (2.2%)

simplify1.0ms (0%)

rewrite1.0ms (0%)

eval6.0ms (0.3%)

prune10.0ms (0.4%)

regimes82.0ms (3.4%)

regimes71.0ms (3%)

regimes56.0ms (2.3%)

regimes41.0ms (1.7%)

regimes34.0ms (1.4%)

regimes3.0ms (0.1%)

regimes2.0ms (0.1%)

regimes24.0ms (1%)

regimes21.0ms (0.9%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch2.0ms (0.1%)

bsearch1.0ms (0%)

simplify6.0ms (0.3%)

soundness2.0ms (0.1%)

preprocess57.0ms (2.4%)

end0.0ms (0%)

Profiling