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

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze15.0ms (0.4%)

Memory

28.2MiB live, 28.2MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.6%	0.4%	0%	0%	0%	0
0%	0%	99.6%	0.4%	0%	0%	0%	1
0%	0%	99.6%	0.4%	0%	0%	0%	2
0%	0%	49.8%	0.4%	0%	49.8%	0%	3
0%	0%	49.8%	0.4%	0%	49.8%	0%	4
0%	0%	49.8%	0.4%	0%	49.8%	0%	5
0%	0%	49.8%	0.4%	0%	49.8%	0%	6
0%	0%	49.8%	0.4%	0%	49.8%	0%	7
100%	24.9%	0%	0.4%	0%	74.7%	0%	8

Compiler

Compiled 23 to 22 computations (4.3% saved)

sample1.7s (41.7%)

Memory

-78.6MiB live, 1 981.5MiB allocated

Samples

1.2s	8 255×	0	valid
0.0ms	1×	1	valid

Precisions

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

ival-log: 217.0ms (33.3% of total)

ival-add: 198.0ms (30.3% of total)

ival-mult: 177.0ms (27.1% of total)

ival-sub: 44.0ms (6.7% of total)

ival-true: 7.0ms (1.1% of total)

exact: 5.0ms (0.8% of total)

ival-assert: 4.0ms (0.6% of total)

adjust: 0.0ms (0% of total)

Bogosity

explain225.0ms (5.5%)

Memory

16.6MiB live, 451.8MiB allocated

FPErrors

Click to see full error table

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

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`+.f64`	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`	nan-rescue	1	0
↳	`(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)`	overflow	2
↳	`(+.f64 (*.f64 x (log.f64 y)) z)`	overflow	2
↳	`(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)`	overflow	2
↳	`(*.f64 x (log.f64 y))`	overflow	2
↳	`(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))`	overflow	2
↳	`(*.f64 y i)`	overflow	37

Confusion

	Predicted +	Predicted -
+	1	0
-	0	255

Precision

1.0

Recall

1.0

Confusion?

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

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	255
1	1

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

82.0ms

512×

valid

Compiler

Compiled 298 to 84 computations (71.8% saved)

Precisions

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

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

ival-log: 13.0ms (29.8% of total)

ival-add: 11.0ms (25.2% of total)

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

ival-true: 1.0ms (2.3% of total)

exact: 0.0ms (0% of total)

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

preprocess12.0ms (0.3%)

Memory

-24.5MiB live, 13.6MiB allocated

Algorithm

1×	egg-herbie

Calls

Call 1

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

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

Compiler

Compiled 21 to 20 computations (4.8% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Alt Table

Click to see full alt table

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

Compiler

Compiled 21 to 20 computations (4.8% saved)

simplify1.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

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

Calls

Call 1

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

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

localize55.0ms (1.3%)

Memory

12.7MiB live, 86.6MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.0078125	(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.1484375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.19921875000000003	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
accuracy	0.29296875	(*.f64 x (log.f64 y))

Samples

33.0ms

256×

valid

Compiler

Compiled 184 to 42 computations (77.2% saved)

Precisions

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

ival-log: 6.0ms (32.8% of total)

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

ival-mult: 5.0ms (27.3% of total)

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

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

exact: 0.0ms (0% of total)

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

series234.0ms (5.7%)

Memory

-5.1MiB live, 439.7MiB allocated

Counts

6 → 85

Calls

Call 1

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

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

Calls

24 calls:

Time	Variable		Point	Expression
50.0ms	x	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* x (log y)) (* (- b 1/2) (log c)))
42.0ms	y	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* x (log y)) (* (- b 1/2) (log c)))
25.0ms	y	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* x (log y)) (* (- b 1/2) (log c)))
15.0ms	c	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* x (log y)) (* (- b 1/2) (log c)))
14.0ms	c	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* x (log y)) (* (- b 1/2) (log c)))

simplify1.0ms (0%)

Memory

2.1MiB live, 2.1MiB allocated

Algorithm

1×	egg-herbie

Counts

85 → 6

Calls

Call 1

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

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

rewrite0.0ms (0%)

Memory

0.8MiB live, 0.8MiB allocated

Counts

6 → 6

Calls

Call 1

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

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

eval1.0ms (0%)

Memory: 2.7MiB live, 2.7MiB allocated
Compiler: Compiled 324 to 44 computations (86.4% saved)

prune3.0ms (0.1%)

Memory

8.0MiB live, 8.0MiB allocated

Pruning

5 alts after pruning (5 fresh and 0 done)

	Pruned	Kept	Total
New	7	5	12
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	8	5	13

Accuracy

99.9%

Counts

13 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	30.2%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶	55.0%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶	83.6%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a)) (.f64 y i))
▶	67.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t)) (.f64 y i))
▶	74.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))

Compiler

Compiled 310 to 252 computations (18.7% saved)

simplify2.0ms (0%)

Memory

2.9MiB live, 2.8MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

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

Calls

Call 1

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

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

localize74.0ms (1.8%)

Memory

-21.5MiB live, 135.7MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.0078125	(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.1484375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.19921875000000003	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
accuracy	62.14136225802979	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.0078125	(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.1484375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	16.218687929635006	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
accuracy	0.1484375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.19921875000000003	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	48.93185470774929	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))
accuracy	0.00390625	(+.f64 (*.f64 x (log.f64 y)) z)
accuracy	0.19921875000000003	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t)) (.f64 y i))
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	28.19234147412527	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))
accuracy	0.00390625	(+.f64 (*.f64 x (log.f64 y)) z)
accuracy	0.19921875000000003	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a)) (.f64 y i))
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	14.952435101686497	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a))

Samples

48.0ms

256×

valid

Compiler

Compiled 838 to 64 computations (92.4% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series169.0ms (4.1%)

Memory

17.6MiB live, 336.4MiB allocated

Counts

17 → 91

Calls

Call 1

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

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

Calls

24 calls:

Time	Variable		Point	Expression
20.0ms	y	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
16.0ms	c	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
16.0ms	y	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
14.0ms	c	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
13.0ms	y	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))

simplify1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated

Algorithm

1×	egg-herbie

Counts

91 → 17

Calls

Call 1

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

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

rewrite1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated

Counts

17 → 17

Calls

Call 1

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

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

eval6.0ms (0.1%)

Memory: 13.6MiB live, 13.6MiB allocated
Compiler: Compiled 2 605 to 127 computations (95.1% saved)

prune7.0ms (0.2%)

Memory

-24.6MiB live, 13.9MiB allocated

Pruning

7 alts after pruning (7 fresh and 0 done)

	Pruned	Kept	Total
New	54	7	61
Fresh	0	0	0
Picked	5	0	5
Done	0	0	0
Total	59	7	66

Accuracy

99.9%

Counts

66 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	71.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t) a)) (.f64 y i))
	69.6%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) t) a)) (.f64 y i))
▶	54.8%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t)) (.f64 y i))
▶	53.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) t)) (.f64 y i))
	60.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
▶	17.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
▶	58.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)))

Compiler

Compiled 632 to 386 computations (38.9% saved)

simplify2.0ms (0%)

Memory

4.1MiB live, 4.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

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

Calls

Call 1

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

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

localize70.0ms (1.7%)

Memory

17.8MiB live, 133.4MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.19921875000000003	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t)) (.f64 y i))
accuracy	28.19234147412527	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t))
accuracy	31.51369172241499	#s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
accuracy	62.14136225802979	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	28.19234147412527	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))) t))
accuracy	31.51369172241499	#s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y))))
accuracy	48.93185470774929	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))
accuracy	0.00390625	(+.f64 (*.f64 x (log.f64 y)) z)
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	14.952435101686497	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a))
accuracy	16.218687929635006	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)))
accuracy	0.0	(-.f64 b #s(literal 1/2 binary64))
accuracy	0.0	(log.f64 c)
accuracy	0.1484375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	52.87795365477793	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.19921875000000003	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t) a)) (.f64 y i))
accuracy	14.952435101686497	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t) a))
accuracy	31.51369172241499	#s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
accuracy	62.14136225802979	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))

Samples

45.0ms

256×

valid

Compiler

Compiled 1 068 to 68 computations (93.6% saved)

Precisions

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

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

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

ival-mult: 5.0ms (25.1% of total)

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

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

exact: 0.0ms (0% of total)

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

series180.0ms (4.4%)

Memory

-39.5MiB live, 375.0MiB allocated

Counts

23 → 99

Calls

Call 1

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

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

Calls

24 calls:

Time	Variable		Point	Expression
18.0ms	a	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (- b 1/2) (log c)) (- b 1/2) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a))
17.0ms	y	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (- b 1/2) (log c)) (- b 1/2) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a))
15.0ms	c	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (- b 1/2) (log c)) (- b 1/2) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a))
14.0ms	c	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (- b 1/2) (log c)) (- b 1/2) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a))
13.0ms	y	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (- b 1/2) (log c)) (- b 1/2) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (+ (* x (log y)) z) (+ (+ (+ (* x (log y)) z) t) a))

simplify2.0ms (0%)

Memory

3.6MiB live, 3.6MiB allocated

Algorithm

1×	egg-herbie

Counts

99 → 23

Calls

Call 1

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

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

rewrite1.0ms (0%)

Memory

3.1MiB live, 3.1MiB allocated

Counts

23 → 23

Calls

Call 1

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

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

eval6.0ms (0.1%)

Memory: 13.6MiB live, 13.6MiB allocated
Compiler: Compiled 2 789 to 118 computations (95.8% saved)

prune9.0ms (0.2%)

Memory

-20.8MiB live, 18.0MiB allocated

Pruning

11 alts after pruning (8 fresh and 3 done)

	Pruned	Kept	Total
New	50	7	57
Fresh	1	1	2
Picked	2	3	5
Done	0	0	0
Total	53	11	64

Accuracy

99.9%

Counts

64 → 11

Alt Table

Click to see full alt table

Status	Accuracy	Program
	44.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64))) a)) (*.f64 y i))
✓	53.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) t)) (.f64 y i))
▶	28.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
▶	27.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (log.f64 c))) (*.f64 y i))
	42.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))
▶	60.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	29.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (*.f64 x (log.f64 y)) z))
✓	17.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓	58.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)))
▶	45.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t) a)))
▶	15.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y))))

Compiler

Compiled 748 to 490 computations (34.5% saved)

simplify2.0ms (0%)

Memory

3.6MiB live, 3.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

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

Calls

Call 1

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

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

localize66.0ms (1.6%)

Memory

15.0MiB live, 133.1MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	14.952435101686497	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t) a))
accuracy	16.218687929635006	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t) a)))
accuracy	31.51369172241499	#s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
accuracy	62.14136225802979	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.0	(log.f64 c)
accuracy	0.19921875000000003	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (log.f64 c))) (*.f64 y i))
accuracy	28.19234147412527	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (log.f64 c)))
accuracy	61.96592045786582	#s(approx (+ (+ (* x (log y)) z) t) (log.f64 c))
accuracy	0.0	(log.f64 y)
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	26.441759605781513	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y))))
accuracy	48.93185470774929	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))
accuracy	0.0	(*.f64 y i)
accuracy	0.19921875000000003	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
accuracy	28.19234147412527	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64))))
accuracy	61.984380953860246	#s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64)))
accuracy	0.1484375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.29296875	(*.f64 x (log.f64 y))
accuracy	16.218687929635006	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
accuracy	19.264176321582507	#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z))

Samples

43.0ms

256×

valid

Compiler

Compiled 909 to 68 computations (92.5% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series172.0ms (4.2%)

Memory

6.6MiB live, 400.9MiB allocated

Counts

24 → 102

Calls

Call 1

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

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

Calls

24 calls:

Time	Variable		Point	Expression
18.0ms	c	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (- b 1/2) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (log y) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (* x (log y)) z) t) a) (+ (* x (log y)) z))
17.0ms	c	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (- b 1/2) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (log y) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (* x (log y)) z) t) a) (+ (* x (log y)) z))
15.0ms	y	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (- b 1/2) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (log y) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (* x (log y)) z) t) a) (+ (* x (log y)) z))
14.0ms	y	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (- b 1/2) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (log y) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (* x (log y)) z) t) a) (+ (* x (log y)) z))
14.0ms	y	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (- b 1/2) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (* x (log y)) z) t) a) (* x (log y)) (log y) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (* x (log y)) z) t) a) (+ (* x (log y)) z))

simplify2.0ms (0%)

Memory

3.5MiB live, 3.5MiB allocated

Algorithm

1×	egg-herbie

Counts

102 → 24

Calls

Call 1

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

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

rewrite1.0ms (0%)

Memory

4.4MiB live, 4.4MiB allocated

Counts

24 → 24

Calls

Call 1

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

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

eval10.0ms (0.2%)

Memory: -23.0MiB live, 15.0MiB allocated
Compiler: Compiled 3 051 to 125 computations (95.9% saved)

prune12.0ms (0.3%)

Memory

32.5MiB live, 32.5MiB allocated

Pruning

15 alts after pruning (9 fresh and 6 done)

	Pruned	Kept	Total
New	51	6	57
Fresh	0	3	3
Picked	1	4	5
Done	1	2	3
Total	53	15	68

Accuracy

99.9%

Counts

68 → 15

Alt Table

Click to see full alt table

Status	Accuracy	Program
	44.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64))) a)) (*.f64 y i))
✓	53.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) t)) (.f64 y i))
✓	28.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
	7.0%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64)))) #s(approx (* y i) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))))
	42.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))
✓	60.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	49.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x #s(approx (log y) (.f64 y i))) z)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	29.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (*.f64 x (log.f64 y)) z))
✓	17.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
	2.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (log.f64 y))
	44.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (*.f64 x (log.f64 y))) t) a)))
	30.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (log.f64 c)) t) a)))
✓	45.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) t) a)))
✓	15.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y))))
	8.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x #s(approx (log y) (.f64 y i)))))

Compiler

Compiled 1 661 to 492 computations (70.4% saved)

regimes108.0ms (2.6%)

Memory

1.1MiB live, 202.1MiB allocated

Counts

26 → 1

Calls

Call 1

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

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

Calls

12 calls:

11.0ms	(log.f64 c)
11.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
11.0ms	z
10.0ms	b
10.0ms	i

Results

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

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes102.0ms (2.5%)

Memory

3.1MiB live, 159.8MiB allocated

Counts

25 → 2

Calls

Call 1

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

Outputs

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

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

Calls

12 calls:

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

Results

Accuracy	Segments	Branch
89.8%	3	`x`
91.6%	2	`y`
87.3%	3	`z`
83.6%	1	`t`
83.6%	1	`a`
92.2%	3	`b`
83.6%	1	`c`
92.4%	3	`i`
90.4%	3	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
91.7%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
92.2%	3	`(-.f64 b #s(literal 1/2 binary64))`
83.6%	1	`(log.f64 c)`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes42.0ms (1%)

Memory

-11.1MiB live, 63.9MiB allocated

Counts

23 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

5 calls:

10.0ms	y
9.0ms	(-.f64 b #s(literal 1/2 binary64))
7.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
7.0ms	i
7.0ms	b

Results

Accuracy	Segments	Branch
91.5%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
91.4%	3	`(-.f64 b #s(literal 1/2 binary64))`
91.4%	3	`b`
83.6%	1	`i`
83.6%	1	`y`

Compiler

Compiled 12 to 46 computations (-283.3% saved)

regimes82.0ms (2%)

Memory

7.7MiB live, 132.7MiB allocated

Counts

19 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

12 calls:

11.0ms	z
8.0ms	c
8.0ms	(-.f64 b #s(literal 1/2 binary64))
6.0ms	(log.f64 c)
6.0ms	a

Results

Accuracy	Segments	Branch
81.0%	3	`a`
76.9%	3	`t`
73.3%	2	`c`
81.4%	4	`i`
73.3%	2	`(log.f64 c)`
79.5%	2	`y`
83.7%	4	`z`
85.5%	3	`x`
79.2%	4	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
79.5%	3	`(-.f64 b #s(literal 1/2 binary64))`
81.2%	4	`b`
83.9%	5	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes28.0ms (0.7%)

Memory

-27.4MiB live, 49.5MiB allocated

Counts

18 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

4 calls:

8.0ms	x
6.0ms	a
6.0ms	z
6.0ms	y

Results

Accuracy	Segments	Branch
81.0%	3	`a`
76.1%	2	`y`
82.0%	4	`z`
74.1%	3	`x`

Compiler

Compiled 4 to 32 computations (-700% saved)

regimes37.0ms (0.9%)

Memory

16.5MiB live, 60.2MiB allocated

Counts

17 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

6 calls:

9.0ms	b
5.0ms	z
5.0ms	a
5.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
5.0ms	i

Results

Accuracy	Segments	Branch
77.5%	3	`(-.f64 b #s(literal 1/2 binary64))`
77.5%	3	`b`
78.4%	3	`i`
78.8%	3	`z`
77.5%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
76.1%	3	`a`

Compiler

Compiled 13 to 54 computations (-315.4% saved)

regimes52.0ms (1.3%)

Memory

17.7MiB live, 94.8MiB allocated

Counts

16 → 2

Calls

Call 1

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

Outputs

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

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

Calls

9 calls:

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

Results

Accuracy	Segments	Branch
72.1%	3	`a`
72.7%	7	`t`
69.9%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
72.9%	5	`b`
69.2%	3	`(-.f64 b #s(literal 1/2 binary64))`
76.1%	5	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
74.5%	2	`y`
72.6%	3	`i`
68.3%	4	`z`

Compiler

Compiled 36 to 90 computations (-150% saved)

regimes25.0ms (0.6%)

Memory

-38.2MiB live, 44.6MiB allocated

Counts

15 → 2

Calls

Call 1

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

Outputs

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

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

Calls

4 calls:

7.0ms	y
5.0ms	(log.f64 c)
5.0ms	c
5.0ms	x

Results

Accuracy	Segments	Branch
72.2%	6	`x`
60.8%	2	`c`
60.8%	2	`(log.f64 c)`
71.9%	2	`y`

Compiler

Compiled 5 to 33 computations (-560% saved)

regimes10.0ms (0.3%)

Memory

18.4MiB live, 18.4MiB allocated

Counts

14 → 5

Calls

Call 1

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

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

Calls

2 calls:

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

Results

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

Compiler

Compiled 22 to 28 computations (-27.3% saved)

regimes47.0ms (1.1%)

Memory

-0.2MiB live, 76.4MiB allocated

Counts

12 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

10 calls:

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

Results

Accuracy	Segments	Branch
58.2%	3	`t`
60.8%	5	`z`
64.1%	4	`x`
53.8%	3	`(-.f64 b #s(literal 1/2 binary64))`
58.6%	5	`b`
58.8%	5	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
63.6%	3	`y`
56.0%	3	`a`
64.1%	4	`i`
67.3%	6	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`

Compiler

Compiled 37 to 98 computations (-164.9% saved)

regimes9.0ms (0.2%)

Memory

16.5MiB live, 16.5MiB allocated

Counts

11 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

2 calls:

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

Results

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

Compiler

Compiled 22 to 28 computations (-27.3% saved)

regimes22.0ms (0.5%)

Memory

-1.9MiB live, 36.2MiB allocated

Counts

10 → 2

Calls

Call 1

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

Outputs

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

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

Calls

5 calls:

7.0ms	x
4.0ms	i
4.0ms	c
4.0ms	y
3.0ms	(log.f64 c)

Results

Accuracy	Segments	Branch
51.6%	4	`c`
51.6%	4	`(log.f64 c)`
60.2%	3	`i`
57.5%	3	`x`
60.3%	2	`y`

Compiler

Compiled 6 to 41 computations (-583.3% saved)

regimes33.0ms (0.8%)

Memory

-19.8MiB live, 60.8MiB allocated

Counts

9 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

8 calls:

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

Results

Accuracy	Segments	Branch
48.1%	2	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
48.6%	3	`a`
55.6%	3	`x`
52.5%	3	`z`
50.3%	2	`t`
51.3%	4	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
52.6%	3	`i`
53.1%	3	`y`

Compiler

Compiled 33 to 80 computations (-142.4% saved)

regimes12.0ms (0.3%)

Memory

-7.6MiB live, 31.6MiB allocated

Counts

7 → 3

Calls

Call 1

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

Outputs

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

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

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

Calls

4 calls:

3.0ms	y
3.0ms	x
3.0ms	b
2.0ms	(-.f64 b #s(literal 1/2 binary64))

Results

Accuracy	Segments	Branch
50.9%	2	`y`
49.8%	3	`(-.f64 b #s(literal 1/2 binary64))`
49.8%	3	`b`
52.9%	3	`x`

Compiler

Compiled 6 to 34 computations (-466.7% saved)

regimes30.0ms (0.7%)

Memory

4.1MiB live, 88.1MiB allocated

Counts

4 → 1

Calls

Call 1

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

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

Calls

12 calls:

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

Results

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

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes20.0ms (0.5%)

Memory

31.6MiB live, 70.7MiB allocated

Counts

2 → 1

Calls

Call 1

Inputs

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

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

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

Calls

12 calls:

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

Results

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

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes17.0ms (0.4%)

Memory

-25.0MiB live, 52.9MiB allocated

Counts

1 → 1

Calls

Call 1

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

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

Calls

12 calls:

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

Results

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

Compiler

Compiled 40 to 115 computations (-187.5% saved)

bsearch19.0ms (0.5%)

Memory

-0.4MiB live, 41.1MiB allocated

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
17.0ms	3.1208924422761865e+33	1.7151602990095136e+34

Samples

13.0ms

96×

valid

Compiler

Compiled 450 to 385 computations (14.4% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.7729932466683287e+223	3.569357123634569e+224
0.0ms	-2.8332763931969006e+71	-2.2370257675178876e+71

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch37.0ms (0.9%)

Memory

12.8MiB live, 91.1MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
20.0ms	2.569118423609373e+135	1.318402442200834e+139
13.0ms	-4.175636123203541e+87	-1.6298973451942748e+87

Samples

25.0ms

208×

valid

Compiler

Compiled 1 064 to 759 computations (28.7% saved)

Precisions

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

ival-log: 5.0ms (34.2% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch38.0ms (0.9%)

Memory

4.3MiB live, 85.2MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
21.0ms	3.2789362418552126e+112	1.1612117932750714e+116
14.0ms	-1.0937141469644962e+148	-4.324830299448352e+147

Samples

26.0ms

208×

valid

Compiler

Compiled 1 038 to 733 computations (29.4% saved)

Precisions

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

ival-log: 5.0ms (33.9% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch50.0ms (1.2%)

Memory

-18.8MiB live, 97.4MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
21.0ms	5.460822369423604e+58	4.747501208174944e+61
23.0ms	-4.227911917367509e+199	-3.293764252860526e+193

Samples

33.0ms

272×

valid

Compiler

Compiled 1 510 to 965 computations (36.1% saved)

Precisions

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

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

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

ival-mult: 5.0ms (26% of total)

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

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

exact: 0.0ms (0% of total)

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

bsearch23.0ms (0.6%)

Memory

-7.2MiB live, 34.4MiB allocated

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
17.0ms	1.15785949891032e+88	4.907637013299142e+89

Samples

12.0ms

112×

valid

Compiler

Compiled 710 to 430 computations (39.4% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch14.0ms (0.3%)

Memory

25.0MiB live, 25.0MiB allocated

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
12.0ms	1.15785949891032e+88	4.907637013299142e+89

Samples

9.0ms

80×

valid

Compiler

Compiled 696 to 416 computations (40.2% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch1.0ms (0%)

Memory

2.0MiB live, 2.0MiB allocated

Algorithm

4×	left-value

Steps

Time	Left	Right
0.0ms	1.7823396574434269e+308	+inf
0.0ms	1.574673108310313e+25	5.90485347701977e+30
0.0ms	-2.6317986119234116e+177	-1.191145619387865e+168
0.0ms	-inf	-1.3060574841387971e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch16.0ms (0.4%)

Memory

-14.9MiB live, 22.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	3.1208924422761865e+33	1.7151602990095136e+34
13.0ms	2.2464408768931427e-180	3.8542289137371506e-180

Samples

11.0ms

64×

valid

Compiler

Compiled 1 140 to 609 computations (46.6% saved)

Precisions

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

ival-mult: 5.0ms (60.1% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch39.0ms (0.9%)

Memory

23.5MiB live, 60.8MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
12.0ms	2.498094100409396e+38	5.239149182832388e+38
23.0ms	4.3394307560713913e-138	8.261057929318008e-135

Samples

22.0ms

208×

valid

Compiler

Compiled 1 034 to 723 computations (30.1% saved)

Precisions

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

ival-log: 5.0ms (34.1% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch25.0ms (0.6%)

Memory

5.6MiB live, 43.1MiB allocated

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
23.0ms	2.509487659166666e+27	7.496147858052836e+29

Samples

18.0ms

128×

valid

Compiler

Compiled 752 to 463 computations (38.4% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch44.0ms (1.1%)

Memory

-43.6MiB live, 58.7MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
27.0ms	1.318402442200834e+139	8.943361504806441e+157
14.0ms	-4.175636123203541e+87	-1.6298973451942748e+87

Samples

32.0ms

192×

valid

Compiler

Compiled 984 to 796 computations (19.1% saved)

Precisions

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

ival-mult: 12.0ms (47.5% of total)

ival-log: 5.0ms (19.8% of total)

ival-sub: 4.0ms (15.8% of total)

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

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

exact: 0.0ms (0% of total)

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

bsearch53.0ms (1.3%)

Memory

8.8MiB live, 84.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
20.0ms	3.535014232663382e+176	5.09705301604335e+178
29.0ms	-6.734912411621824e+224	-1.3488265079021546e+213

Samples

37.0ms

272×

valid

Compiler

Compiled 1 265 to 898 computations (29% saved)

Precisions

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

ival-log: 11.0ms (41.4% of total)

ival-mult: 8.0ms (30.1% of total)

ival-add: 6.0ms (22.6% of total)

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

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

exact: 0.0ms (0% of total)

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

simplify5.0ms (0.1%)

Memory: 14.7MiB live, 14.7MiB allocated

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze15.0ms (0.4%)

sample1.7s (41.7%)

explain225.0ms (5.5%)

preprocess12.0ms (0.3%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify1.0ms (0%)

localize55.0ms (1.3%)

series234.0ms (5.7%)

simplify1.0ms (0%)

rewrite0.0ms (0%)

eval1.0ms (0%)

prune3.0ms (0.1%)

simplify2.0ms (0%)

localize74.0ms (1.8%)

series169.0ms (4.1%)

simplify1.0ms (0%)

rewrite1.0ms (0%)

eval6.0ms (0.1%)

prune7.0ms (0.2%)

simplify2.0ms (0%)

localize70.0ms (1.7%)

series180.0ms (4.4%)

simplify2.0ms (0%)

rewrite1.0ms (0%)

eval6.0ms (0.1%)

prune9.0ms (0.2%)

simplify2.0ms (0%)

localize66.0ms (1.6%)

series172.0ms (4.2%)

simplify2.0ms (0%)

rewrite1.0ms (0%)

eval10.0ms (0.2%)

prune12.0ms (0.3%)

regimes108.0ms (2.6%)

regimes102.0ms (2.5%)

regimes42.0ms (1%)

regimes82.0ms (2%)

regimes28.0ms (0.7%)

regimes37.0ms (0.9%)

regimes52.0ms (1.3%)

regimes25.0ms (0.6%)

regimes10.0ms (0.3%)

regimes47.0ms (1.1%)

regimes9.0ms (0.2%)

regimes22.0ms (0.5%)

regimes33.0ms (0.8%)

regimes12.0ms (0.3%)

regimes30.0ms (0.7%)

regimes20.0ms (0.5%)

regimes17.0ms (0.4%)

bsearch19.0ms (0.5%)

bsearch1.0ms (0%)

bsearch37.0ms (0.9%)

bsearch38.0ms (0.9%)

bsearch50.0ms (1.2%)

bsearch23.0ms (0.6%)

bsearch14.0ms (0.3%)

bsearch1.0ms (0%)

bsearch16.0ms (0.4%)

bsearch39.0ms (0.9%)

bsearch25.0ms (0.6%)

bsearch44.0ms (1.1%)

bsearch53.0ms (1.3%)

simplify5.0ms (0.1%)

end0.0ms (0%)

Profiling