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

6.0MiB live, 6.0MiB 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.3s (51.2%)

Memory

-77.9MiB live, 1 392.2MiB allocated

Samples

707.0ms	8 254×	0	valid
0.0ms	2×	1	valid

Precisions

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

ival-add: 127.0ms (28.2% of total)

ival-mult: 127.0ms (28.2% of total)

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

ival-sub: 78.0ms (17.3% of total)

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

exact: 5.0ms (1.1% of total)

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

adjust: 0.0ms (0% of total)

Bogosity

explain139.0ms (5.4%)

Memory

7.5MiB live, 204.3MiB 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: 26.0ms

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

ival-log: 7.0ms (26.4% of total)

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

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

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

exact: 0.0ms (0% of total)

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

preprocess5.0ms (0.2%)

Memory

9.1MiB live, 9.1MiB 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.1MiB live, 0.1MiB allocated
Compiler: Compiled 0 to 6 computations (-∞% saved)

prune0.0ms (0%)

Memory

0.8MiB live, 0.8MiB 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

0.8MiB live, 0.8MiB 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

localize35.0ms (1.3%)

Memory

6.4MiB live, 45.8MiB allocated

Localize:

Found 4 expressions of interest:

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

Samples

24.0ms

256×

valid

Compiler

Compiled 112 to 32 computations (71.4% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series120.0ms (4.7%)

Memory

1.3MiB live, 188.4MiB allocated

Counts

6 → 59

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))
(*.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 (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
33.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)) (* (- a 1/2) b))
18.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)) (* (- a 1/2) b))
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)) (* (- a 1/2) b))
11.0ms	a	@	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)) (* (- a 1/2) b))
10.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)) (* (- a 1/2) b))

simplify1.0ms (0%)

Memory

1.6MiB live, 1.6MiB allocated

Algorithm

1×	egg-herbie

Counts

59 → 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)))
(- (+ 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)))
(+.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))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

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))
(*.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))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(*.f64 z (log.f64 t))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

eval1.0ms (0.1%)

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

prune1.0ms (0.1%)

Memory

3.6MiB live, 3.6MiB 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))
▶	81.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	81.1%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	62.1%	#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.7MiB live, 1.7MiB 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

localize46.0ms (1.8%)

Memory

-2.8MiB live, 73.1MiB allocated

Localize:

Found 12 expressions of interest:

New	Metric	Score
accuracy	0.0	(+.f64 x y)
accuracy	0.01171875	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	0.015625	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	16.912747090329876	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
accuracy	0.0	(+.f64 x y)
accuracy	0.01171875	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	0.015625	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	17.67349424871813	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
accuracy	0.0	(log.f64 t)
accuracy	0.06375753162065376	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
accuracy	0.27734375	(*.f64 z (log.f64 t))
accuracy	24.204027186360346	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))

Samples

28.0ms

256×

valid

Compiler

Compiled 301 to 45 computations (85% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series79.0ms (3.1%)

Memory

6.2MiB live, 134.6MiB 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	y	@	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))
11.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))
10.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))
8.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))
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))

simplify3.0ms (0.1%)

Memory

1.5MiB live, 1.5MiB 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

-37.7MiB live, 1.3MiB 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)

eval3.0ms (0.1%)

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

prune7.0ms (0.3%)

Memory

15.4MiB live, 15.3MiB allocated

Pruning

13 alts after pruning (9 fresh and 4 done)

	Pruned	Kept	Total
New	20	9	29
Fresh	0	0	0
Picked	0	3	3
Done	0	1	1
Total	20	13	33

Accuracy

99.9%

Counts

33 → 13

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))
✓	81.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	60.2%	(+.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))
	20.0%	(+.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))
✓	81.1%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	19.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))
✓	62.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
	56.3%	#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))))
	2.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
	44.5%	#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.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
▶	2.8%	#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 663 to 423 computations (36.2% saved)

simplify1.0ms (0.1%)

Memory

3.1MiB live, 3.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 18 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	(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 (-.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 #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))

Calls

Call 1

Inputs
(+.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)) #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
#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
#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
(+.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)) #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
#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
#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

localize51.0ms (2%)

Memory

-20.0MiB live, 102.3MiB allocated

Localize:

Found 18 expressions of interest:

New	Metric	Score
accuracy	0.27734375	(*.f64 z (log.f64 t))
accuracy	16.912747090329876	#s(approx (+ (+ x y) z) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
accuracy	17.67349424871813	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
accuracy	24.204027186360346	#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.0	(log.f64 t)
accuracy	24.204027186360346	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
accuracy	61.804732987896955	#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
accuracy	0.01171875	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	0.015625	(+.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	17.67349424871813	#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
accuracy	61.78972175030709	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0	(+.f64 x y)
accuracy	17.67349424871813	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
accuracy	24.204027186360346	#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.015625	(+.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	16.912747090329876	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
accuracy	16.912747090329876	#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.0227992227294	#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)))

Samples

33.0ms

256×

valid

Compiler

Compiled 712 to 55 computations (92.3% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series81.0ms (3.2%)

Memory

14.6MiB live, 168.4MiB allocated

Counts

19 → 62

Calls

Call 1

Inputs
(+.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)) #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)))
#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))) (* (- 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 (+.f64 x y) z))
(*.f64 z (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 (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))))))
(+ (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
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) (+ (- (+ (+ 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))) (+ x y) (* (- 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))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (- (+ (+ x y) z) (* z (log t))) (* z (log t)))
11.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))) (+ x y) (* (- 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))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (- (+ (+ x y) z) (* z (log t))) (* z (log t)))
8.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))) (+ x y) (* (- 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))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (- (+ (+ x y) z) (* z (log t))) (* 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))) (+ x y) (* (- 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))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (- (+ (+ x y) z) (* z (log t))) (* 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))) (+ x y) (* (- 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))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z) (- (+ (+ x y) z) (* z (log t))) (* z (log t)))

simplify1.0ms (0%)

Memory

2.2MiB live, 2.2MiB allocated

Algorithm

1×	egg-herbie

Counts

62 → 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)))
(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)))
(* -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))))))
(+ (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)))
(+.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 (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
#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))
(- (+ 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 (+ y z)) (* z (log t)))
#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)))
(+ 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)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(* x (+ 1 (+ (/ y x) (/ z x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
(* x (+ 1 (/ y x)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(log.f64 t)
(* -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)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
(- (+ x z) (* z (log t)))
(*.f64 z (log.f64 t))

rewrite1.0ms (0%)

Memory

2.9MiB live, 2.8MiB allocated

Counts

19 → 19

Calls

Call 1

Inputs
(+.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)) #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)))
#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))) (* (- 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 (+.f64 x y) z))
(*.f64 z (log.f64 t))

Outputs
(+.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)) #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)))
#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))) (* (- 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 (+.f64 x y) z))
(*.f64 z (log.f64 t))

eval5.0ms (0.2%)

Memory: 10.8MiB live, 10.8MiB allocated
Compiler: Compiled 1 649 to 79 computations (95.2% saved)

prune10.0ms (0.4%)

Memory

-15.0MiB live, 23.3MiB allocated

Pruning

13 alts after pruning (5 fresh and 8 done)

	Pruned	Kept	Total
New	41	2	43
Fresh	1	3	4
Picked	1	4	5
Done	0	4	4
Total	43	13	56

Accuracy

99.9%

Counts

56 → 13

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))
✓	81.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	81.1%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	19.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))
✓	62.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
▶	56.3%	#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))))
▶	2.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
▶	44.5%	#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)))
▶	81.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) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)))
✓	43.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
✓	2.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
▶	39.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))

Compiler

Compiled 574 to 362 computations (36.9% saved)

simplify2.0ms (0.1%)

Memory

3.1MiB live, 3.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

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

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 #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) 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)) #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)) #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) 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)) (*.f64 z (log.f64 t)))
(*.f64 z (log.f64 t))
z
(log.f64 t)
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 #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

localize58.0ms (2.2%)

Memory

14.1MiB live, 96.2MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score
accuracy	0.06375753162065376	(-.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	24.204027186360346	#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	61.78972175030709	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0	(log.f64 t)
accuracy	0.27734375	(*.f64 z (log.f64 t))
accuracy	62.4816113596907	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
accuracy	0.01171875	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	17.67349424871813	#s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
accuracy	24.204027186360346	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
accuracy	61.78972175030709	#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0.0	(+.f64 (+.f64 x y) z)
accuracy	0.0	(+.f64 x y)
accuracy	16.912747090329876	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
accuracy	24.204027186360346	#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)))
accuracy	16.912747090329876	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
accuracy	16.912747090329876	#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	24.204027186360346	#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 #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.0227992227294	#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)))

Samples

41.0ms

256×

valid

Compiler

Compiled 701 to 53 computations (92.4% saved)

Precisions

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

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

ival-add: 3.0ms (16.7% 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)

series84.0ms (3.3%)

Memory

-33.7MiB live, 129.4MiB allocated

Counts

18 → 62

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 #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) 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)) #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)) #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) 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)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
(*.f64 z (log.f64 t))
(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 #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)

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
15.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) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* z (log t)) (log t) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z))
12.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) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* z (log t)) (log t) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z))
8.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) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* z (log t)) (log t) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z))
7.0ms	x	@	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) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* z (log t)) (log t) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z))
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) z) (+ x y) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ x y) (* (- a 1/2) b) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (* z (log t)) (log t) (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (- (+ (+ x y) z) (* z (log t))) (+ (+ x y) z))

simplify1.0ms (0%)

Memory

1.4MiB live, 1.4MiB allocated

Algorithm

1×	egg-herbie

Counts

62 → 18

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)) #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 (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
#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))
(- (+ 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 (+ y z)) (* z (log t)))
#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)))
(+ y 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)))
(+ x (+ y z))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z))
y
(+.f64 (+.f64 x y) z)
(+ x y)
(+.f64 x y)
x
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #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)))
#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))) (/ (* z (log t)) x)))
#s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(* x (+ 1 (+ (/ y x) (/ z x))))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(* x (+ 1 (/ y x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 z (log.f64 t))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(log.f64 t)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
#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))))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(-.f64 (+.f64 #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z) (.f64 z (log.f64 t)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z)

rewrite1.0ms (0%)

Memory

1.6MiB live, 1.6MiB allocated

Counts

18 → 18

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 #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) 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)) #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)) #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) 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)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
(*.f64 z (log.f64 t))
(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 #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)

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 #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) 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)) #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)) #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) 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)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
(*.f64 z (log.f64 t))
(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 #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)

eval4.0ms (0.2%)

Memory: 8.5MiB live, 8.5MiB allocated
Compiler: Compiled 1 665 to 71 computations (95.7% saved)

prune13.0ms (0.5%)

Memory

-12.9MiB live, 25.7MiB allocated

Pruning

15 alts after pruning (2 fresh and 13 done)

	Pruned	Kept	Total
New	37	2	39
Fresh	0	0	0
Picked	0	5	5
Done	0	8	8
Total	37	15	52

Accuracy

99.9%

Counts

52 → 15

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))
✓	81.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	81.1%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓	19.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))
✓	62.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))))
✓	56.3%	#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))))
	40.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) z))
✓	2.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 z (log.f64 t)))
✓	44.5%	#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)))
	44.5%	#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 x y) z)) z)))
✓	81.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) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)))
✓	43.7%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
✓	2.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (log.f64 t)))
✓	39.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))

Compiler

Compiled 995 to 352 computations (64.6% saved)

regimes84.0ms (3.3%)

Memory

6.4MiB live, 123.8MiB allocated

Counts

17 → 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 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) 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))
#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 #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) 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))) (+.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)) (*.f64 z (log.f64 t)))
#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:

12.0ms	a
10.0ms	(+.f64 x y)
9.0ms	x
6.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
6.0ms	b

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)

regimes73.0ms (2.8%)

Memory

19.7MiB live, 180.0MiB allocated

Counts

16 → 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 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) 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))
#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 #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) 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))) (+.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)) (*.f64 z (log.f64 t)))
#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

#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 #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) 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)) #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)))

Calls

12 calls:

9.0ms	a
7.0ms	(log.f64 t)
6.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
6.0ms	y
6.0ms	(+.f64 x y)

Results

Accuracy	Segments	Branch
81.8%	1	`x`
81.8%	1	`y`
91.4%	3	`z`
83.8%	2	`t`
87.1%	3	`a`
90.1%	3	`b`
81.8%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
83.9%	2	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
87.1%	3	`(+.f64 x y)`
83.8%	2	`(log.f64 t)`
92.0%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
86.1%	3	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes46.0ms (1.8%)

Memory

10.7MiB live, 88.4MiB allocated

Counts

14 → 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 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) 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))
#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 #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) 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))) (+.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)) (*.f64 z (log.f64 t)))
#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

#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 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z)))

Calls

9 calls:

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

Results

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

Compiler

Compiled 27 to 66 computations (-144.4% saved)

regimes43.0ms (1.7%)

Memory

0.9MiB live, 81.0MiB allocated

Counts

8 → 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 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) 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))

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

12 calls:

6.0ms	(log.f64 t)
4.0ms	x
3.0ms	(+.f64 x y)
3.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
3.0ms	a

Results

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

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes36.0ms (1.4%)

Memory

-3.7MiB live, 73.2MiB allocated

Counts

6 → 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 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) 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:

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

Results

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

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes41.0ms (1.6%)

Memory

-9.8MiB live, 74.4MiB 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 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.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)) (+.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) (+.f64 (+.f64 x y) z)) z)))

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

Calls

12 calls:

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

Results

Accuracy	Segments	Branch
53.2%	3	`y`
50.1%	3	`z`
49.4%	4	`t`
49.4%	4	`(log.f64 t)`
69.6%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
64.3%	3	`b`
60.4%	3	`(-.f64 a #s(literal 1/2 binary64))`
54.9%	3	`x`
60.4%	3	`a`
59.8%	3	`(+.f64 x y)`
57.5%	3	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
61.3%	5	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes3.0ms (0.1%)

Memory

7.5MiB live, 7.5MiB 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 (+.f64 x y) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) 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) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 #s(approx (+ x y) (+.f64 (+.f64 x y) z)) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.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
69.4%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 5 to 9 computations (-80% saved)

regimes2.0ms (0.1%)

Memory

6.2MiB live, 6.2MiB allocated

Counts

3 → 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 (+.f64 x y) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #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))) #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 (+.f64 x y) z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.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
69.4%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 5 to 9 computations (-80% saved)

regimes22.0ms (0.9%)

Memory

-30.3MiB live, 47.2MiB allocated

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 (+.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:

4.0ms	b
2.0ms	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	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
1.0ms	(log.f64 t)

Results

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

Compiler

Compiled 45 to 93 computations (-106.7% saved)

regimes16.0ms (0.6%)

Memory

-1.3MiB live, 41.1MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 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)))

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:

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

Results

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

Compiler

Compiled 45 to 93 computations (-106.7% saved)

bsearch34.0ms (1.3%)

Memory

26.6MiB live, 64.8MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
17.0ms	9.621297394325211e+39	3.0771240730986844e+49
14.0ms	-5.60585854705389e+128	-2.2925491956621337e+125

Samples

20.0ms	271×	0	valid
0.0ms	1×	1	valid

Compiler

Compiled 1 362 to 806 computations (40.8% saved)

Precisions

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

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

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

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

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

adjust: 0.0ms (0% of total)

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

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

bsearch24.0ms (0.9%)

Memory

-1.1MiB live, 37.2MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
10.0ms	3.4784513685297496e+199	2.9540967013282378e+200
11.0ms	-1.4854479226112742e+114	-7.174854899556806e+113

Samples

15.0ms

176×

valid

Compiler

Compiled 766 to 475 computations (38% saved)

Precisions

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

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

ival-log: 2.0ms (21.4% of total)

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

ival-mult: 1.0ms (10.7% of total)

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

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

bsearch2.0ms (0.1%)

Memory

3.6MiB live, 3.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	3.4784513685297496e+199	2.9540967013282378e+200
1.0ms	-1.4854479226112742e+114	-7.174854899556806e+113

Compiler

Compiled 811 to 475 computations (41.4% saved)

bsearch2.0ms (0.1%)

Memory

3.3MiB live, 3.3MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	3.4784513685297496e+199	2.9540967013282378e+200
1.0ms	-1.4854479226112742e+114	-7.174854899556806e+113

Compiler

Compiled 745 to 453 computations (39.2% saved)

simplify7.0ms (0.3%)

Memory

-23.6MiB live, 14.9MiB 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 -230000000000000012780930231873428186770625938965526796539758599638312011047756831731003125032436136698199092760180171233820672 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 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 360000000000000000065636053397386469109137408 binary64)) #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)) #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)))))
#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 #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) 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 -1420000000000000131456907142993513313085957339508975503043545768872405790542483419133929213648163536875871769985024 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (+.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 34999999999999998090838488931035300178266484156976023199535624469370319833333305316323022664283599771149625721224001772640820329034495845069257824122202374199626290846836730523783601320529344648445952 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 x y) z)) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1420000000000000131456907142993513313085957339508975503043545768872405790542483419133929213648163536875871769985024 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 34999999999999998090838488931035300178266484156976023199535624469370319833333305316323022664283599771149625721224001772640820329034495845069257824122202374199626290846836730523783601320529344648445952 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 x y) z)) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1420000000000000131456907142993513313085957339508975503043545768872405790542483419133929213648163536875871769985024 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 34999999999999998090838488931035300178266484156976023199535624469370319833333305316323022664283599771149625721224001772640820329034495845069257824122202374199626290846836730523783601320529344648445952 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))) #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 (+.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 -230000000000000012780930231873428186770625938965526796539758599638312011047756831731003125032436136698199092760180171233820672 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 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 (+.f64 x y) z)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))) z))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 360000000000000000065636053397386469109137408 binary64)) #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)) #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)))))
#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 #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) 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 -1420000000000000131456907142993513313085957339508975503043545768872405790542483419133929213648163536875871769985024 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (+.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 34999999999999998090838488931035300178266484156976023199535624469370319833333305316323022664283599771149625721224001772640820329034495845069257824122202374199626290846836730523783601320529344648445952 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 x y) z)) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1420000000000000131456907142993513313085957339508975503043545768872405790542483419133929213648163536875871769985024 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 34999999999999998090838488931035300178266484156976023199535624469370319833333305316323022664283599771149625721224001772640820329034495845069257824122202374199626290846836730523783601320529344648445952 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 x y) z)) z))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1420000000000000131456907142993513313085957339508975503043545768872405790542483419133929213648163536875871769985024 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 34999999999999998090838488931035300178266484156976023199535624469370319833333305316323022664283599771149625721224001772640820329034495845069257824122202374199626290846836730523783601320529344648445952 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))) #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 (+.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.3MiB live, 5.3MiB allocated

Stop Event

1×

fuel

Compiler

Compiled 705 to 59 computations (91.6% saved)

preprocess60.0ms (2.3%)

Memory: -7.0MiB live, 108.6MiB allocated
Compiler: Compiled 1 488 to 188 computations (87.4% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze3.0ms (0.1%)

sample1.3s (51.2%)

explain139.0ms (5.4%)

preprocess5.0ms (0.2%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify0.0ms (0%)

localize35.0ms (1.3%)

series120.0ms (4.7%)

simplify1.0ms (0%)

rewrite0.0ms (0%)

eval1.0ms (0.1%)

prune1.0ms (0.1%)

simplify1.0ms (0%)

localize46.0ms (1.8%)

series79.0ms (3.1%)

simplify3.0ms (0.1%)

rewrite1.0ms (0%)

eval3.0ms (0.1%)

prune7.0ms (0.3%)

simplify1.0ms (0.1%)

localize51.0ms (2%)

series81.0ms (3.2%)

simplify1.0ms (0%)

rewrite1.0ms (0%)

eval5.0ms (0.2%)

prune10.0ms (0.4%)

simplify2.0ms (0.1%)

localize58.0ms (2.2%)

series84.0ms (3.3%)

simplify1.0ms (0%)

rewrite1.0ms (0%)

eval4.0ms (0.2%)

prune13.0ms (0.5%)

regimes84.0ms (3.3%)

regimes73.0ms (2.8%)

regimes46.0ms (1.8%)

regimes43.0ms (1.7%)

regimes36.0ms (1.4%)

regimes41.0ms (1.6%)

regimes3.0ms (0.1%)

regimes2.0ms (0.1%)

regimes22.0ms (0.9%)

regimes16.0ms (0.6%)

bsearch34.0ms (1.3%)

bsearch24.0ms (0.9%)

bsearch2.0ms (0.1%)

bsearch2.0ms (0.1%)

simplify7.0ms (0.3%)

soundness2.0ms (0.1%)

preprocess60.0ms (2.3%)

end0.0ms (0%)

Profiling