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

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze21.0ms (0.5%)

Memory

-31.5MiB live, 30.1MiB 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.5s (38%)

Memory

70.3MiB live, 2 127.5MiB allocated

Samples

1.0s	8 251×	0	valid
1.0ms	3×	1	valid
1.0ms	2×	2	valid

Precisions

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

ival-log: 239.0ms (34.3% of total)

ival-add: 197.0ms (28.3% of total)

ival-mult: 192.0ms (27.6% of total)

ival-sub: 51.0ms (7.3% of total)

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

exact: 5.0ms (0.7% of total)

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

adjust: 0.0ms (0% of total)

Bogosity

explain337.0ms (8.8%)

Memory

-106.9MiB live, 327.7MiB allocated

FPErrors

Click to see full error table

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

Confusion

	Predicted +	Predicted -
+	0	0
-	0	256

Precision

0/0

Recall

0/0

Confusion?

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

Precision?

0/0

Recall?

0/0

Freqs

test

number	freq
0	256

Total Confusion?

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

Precision?

0/0

Recall?

0/0

Samples

76.0ms

512×

valid

Compiler

Compiled 298 to 84 computations (71.8% saved)

Precisions

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

ival-log: 16.0ms (38% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

preprocess7.0ms (0.2%)

Memory

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

prune1.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.9%	(+.f64 (+.f64 (+.f64 (+.f64 (+.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

localize48.0ms (1.3%)

Memory

-4.3MiB live, 72.0MiB allocated

Localize:

Found 4 expressions of interest:

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

Samples

37.0ms

256×

valid

Compiler

Compiled 184 to 42 computations (77.2% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series247.0ms (6.4%)

Memory

11.9MiB live, 404.0MiB allocated

Counts

7 → 91

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

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)))))
(* 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))))
(+ 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)))))
(+ 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 (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
54.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)) (+ (* x (log y)) z))
41.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)) (+ (* x (log y)) z))
24.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)) (+ (* x (log y)) z))
19.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)) (+ (* x (log y)) z))
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)) (* (- b 1/2) (log c)) (+ (* x (log y)) z))

simplify1.0ms (0%)

Memory

2.6MiB live, 2.6MiB allocated

Algorithm

1×	egg-herbie

Counts

91 → 7

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

rewrite0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Counts

7 → 7

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

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

eval2.0ms (0%)

Memory: 3.6MiB live, 3.6MiB allocated
Compiler: Compiled 373 to 48 computations (87.1% saved)

prune5.0ms (0.1%)

Memory

-31.2MiB live, 8.1MiB allocated

Pruning

5 alts after pruning (5 fresh and 0 done)

	Pruned	Kept	Total
New	9	5	14
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	10	5	15

Accuracy

99.9%

Counts

15 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	81.9%	(+.f64 (+.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 y i))
▶	50.2%	(+.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))
▶	82.9%	(+.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))
▶	68.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))
▶	80.7%	#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 258 computations (16.8% saved)

simplify2.0ms (0%)

Memory

4.6MiB live, 4.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score	Program
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	(+.f64 (+.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 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 (+.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 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 #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 y i)
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 (+.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 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 #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 y i)
i

localize85.0ms (2.2%)

Memory

27.9MiB live, 178.8MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.015625	(+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)) a)
accuracy	0.15625	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	20.709737073387952	#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z))
accuracy	0.015625	(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
accuracy	0.15625	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	12.272278313137715	#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.01171875	(+.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)))
accuracy	0.15625	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	47.013017805763084	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))
accuracy	0.00390625	(+.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.01171875	(+.f64 (*.f64 x (log.f64 y)) z)
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	26.40057243845972	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))
accuracy	0.01171875	(+.f64 (*.f64 x (log.f64 y)) z)
accuracy	0.015625	(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	15.199573752337008	#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

55.0ms

256×

valid

Compiler

Compiled 891 to 65 computations (92.7% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series204.0ms (5.3%)

Memory

7.8MiB live, 370.4MiB allocated

Counts

18 → 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 (+.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 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 #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 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	@	-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) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)))
20.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) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)))
20.0ms	x	@	-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) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)))
18.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)) 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) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)))
18.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) (+ (+ (* x (log y)) z) t) (* (- b 1/2) (log c)))

simplify4.0ms (0.1%)

Memory

-41.1MiB live, 4.2MiB allocated

Algorithm

1×	egg-herbie

Counts

91 → 18

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

rewrite1.0ms (0%)

Memory

2.8MiB live, 2.8MiB allocated

Counts

18 → 18

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 (+.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 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 #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 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 (+.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 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 #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 b #s(literal 1/2 binary64)) (log.f64 c))

eval7.0ms (0.2%)

Memory: 15.5MiB live, 15.5MiB allocated
Compiler: Compiled 2 844 to 143 computations (95% saved)

prune7.0ms (0.2%)

Memory

17.6MiB live, 17.6MiB allocated

Pruning

9 alts after pruning (8 fresh and 1 done)

	Pruned	Kept	Total
New	59	8	67
Fresh	0	0	0
Picked	4	1	5
Done	0	0	0
Total	63	9	72

Accuracy

99.9%

Counts

72 → 9

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	81.9%	(+.f64 (+.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 y i))
▶	65.7%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y))))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	36.1%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
▶	61.8%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.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 y i))
▶	50.8%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z))) (.f64 y i))
▶	62.7%	#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))))
	65.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	63.9%	#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)))
▶	31.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)))

Compiler

Compiled 770 to 462 computations (40% saved)

simplify5.0ms (0.1%)

Memory

-33.8MiB live, 4.8MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

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

Calls

Call 1

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

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

localize79.0ms (2%)

Memory

14.0MiB live, 172.8MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.15625	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	12.272278313137715	#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	20.709737073387952	#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	15.199573752337008	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.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	23.109748111659858	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.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	26.40057243845972	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))
accuracy	0.01171875	(+.f64 (*.f64 x (log.f64 y)) z)
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	20.709737073387952	#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z))
accuracy	26.40057243845972	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)))
accuracy	0.01171875	(+.f64 (*.f64 x (log.f64 y)) z)
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	20.709737073387952	#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z))
accuracy	32.58708284794888	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	20.709737073387952	#s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))))
accuracy	32.39259410175961	#s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y))))
accuracy	47.013017805763084	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))

Samples

50.0ms

256×

valid

Compiler

Compiled 1 172 to 69 computations (94.1% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series167.0ms (4.3%)

Memory

12.0MiB live, 335.2MiB allocated

Counts

21 → 91

Calls

Call 1

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

simplify2.0ms (0%)

Memory

2.5MiB live, 2.5MiB allocated

Algorithm

1×	egg-herbie

Counts

91 → 21

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

rewrite1.0ms (0%)

Memory

3.9MiB live, 3.9MiB allocated

Counts

21 → 21

Calls

Call 1

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

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

eval8.0ms (0.2%)

Memory: -24.9MiB live, 13.4MiB allocated
Compiler: Compiled 3 715 to 158 computations (95.7% saved)

prune10.0ms (0.3%)

Memory

22.1MiB live, 22.1MiB allocated

Pruning

14 alts after pruning (11 fresh and 3 done)

	Pruned	Kept	Total
New	55	8	63
Fresh	0	3	3
Picked	2	3	5
Done	1	0	1
Total	58	14	72

Accuracy

99.9%

Counts

72 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	65.7%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y))))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶	66.4%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log 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) (+.f64 (.f64 x (log.f64 y)) z)))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶	36.1%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	61.7%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log 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) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z))) (.f64 y i))) t)) (.f64 y i)))) (.f64 y i))
▶	48.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log 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) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)) (.f64 y i)))) (*.f64 y i))
▶	35.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) (.f64 y i))
✓	50.8%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z))) (.f64 y i))
	44.5%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z))) (.f64 y i))))) (*.f64 y i))
	47.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y))))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	65.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	46.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)) a))
	63.9%	#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)))
✓	31.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)))
▶	17.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))))

Compiler

Compiled 1 380 to 710 computations (48.6% saved)

simplify2.0ms (0.1%)

Memory

4.7MiB live, 4.7MiB 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) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)) (.f64 y i))
cost-diff	0	#s(approx (+ (+ (+ (* x (log 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) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)) (.f64 y i)))
cost-diff	0	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log 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) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)) (.f64 y i))))
cost-diff	0	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log 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) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)) (.f64 y i)))) (*.f64 y i))
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))) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
cost-diff	0	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
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))) #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) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) (.f64 y i))
cost-diff	0	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
cost-diff	0	#s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
cost-diff	0	#s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (*.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)) #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (*.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)) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)))
cost-diff	0	#s(approx (+ (+ (+ (* x (log 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) (+.f64 (*.f64 x (log.f64 y)) z))))
cost-diff	0	(+.f64 #s(approx (+ (+ (+ (* x (log 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) (+.f64 (.f64 x (log.f64 y)) z)))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
cost-diff	0	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log 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) (+.f64 (.f64 x (log.f64 y)) z)))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))

Calls

Call 1

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

localize74.0ms (1.9%)

Memory

-22.5MiB live, 135.2MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	15.199573752337008	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log 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) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)) (.f64 y i))))
accuracy	23.109748111659858	#s(approx (+ (+ (+ (* x (log 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) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)) (.f64 y i)))
accuracy	26.40057243845972	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 #s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t))
accuracy	61.72948687460341	#s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.0	(log.f64 c)
accuracy	0.00390625	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
accuracy	0.15625	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	48.553439196302705	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.00390625	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) (.f64 y i))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	15.199573752337008	#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y))))
accuracy	47.013017805763084	#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 x (log.f64 y)))
accuracy	0.15625	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	20.709737073387952	#s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
accuracy	32.58708284794888	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))))
accuracy	61.72948687460341	#s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.25390625	(*.f64 x (log.f64 y))
accuracy	20.709737073387952	#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z))
accuracy	23.109748111659858	#s(approx (+ (+ (+ (* x (log 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) (+.f64 (*.f64 x (log.f64 y)) z))))
accuracy	32.58708284794888	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)))

Samples

49.0ms

256×

valid

Compiler

Compiled 1 208 to 69 computations (94.3% saved)

Precisions

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

ival-mult: 9.0ms (37.3% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

series173.0ms (4.5%)

Memory

16.3MiB live, 369.6MiB allocated

Counts

22 → 99

Calls

Call 1

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

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
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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (- 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (- b 1/2) (+ (+ (+ (+ (+ (* 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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- 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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (- 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (- b 1/2) (+ (+ (+ (+ (+ (* 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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))))
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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (- 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (- b 1/2) (+ (+ (+ (+ (+ (* 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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))))
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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (- 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (- b 1/2) (+ (+ (+ (+ (+ (* 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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (- 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (- b 1/2) (+ (+ (+ (+ (+ (* 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) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (* x (log y)) z) t) (log c) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))))

simplify2.0ms (0%)

Memory

3.7MiB live, 3.7MiB allocated

Algorithm

1×	egg-herbie

Counts

99 → 22

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

rewrite1.0ms (0%)

Memory

3.1MiB live, 3.1MiB allocated

Counts

22 → 22

Calls

Call 1

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

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

eval8.0ms (0.2%)

Memory: -27.6MiB live, 13.4MiB allocated
Compiler: Compiled 3 301 to 121 computations (96.3% saved)

prune15.0ms (0.4%)

Memory

5.9MiB live, 44.9MiB allocated

Pruning

18 alts after pruning (11 fresh and 7 done)

	Pruned	Kept	Total
New	52	5	57
Fresh	0	6	6
Picked	1	4	5
Done	0	3	3
Total	53	18	71

Accuracy

99.9%

Counts

71 → 18

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	65.7%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y))))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
✓	66.4%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log 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) (+.f64 (.f64 x (log.f64 y)) z)))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
✓	36.1%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	61.7%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log 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) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z))) (.f64 y i))) t)) (.f64 y i)))) (.f64 y i))
✓	35.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y)))) (.f64 y i))
✓	50.8%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z))) (.f64 y i))
	44.5%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (.f64 x (log.f64 y)) z))) (.f64 y i))))) (*.f64 y i))
	47.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 x (log.f64 y))))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	47.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (+ (* x (log 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) (+.f64 (.f64 x (log.f64 y)) z)))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	65.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t))) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
	46.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)) a))
	16.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 x (log.f64 y)))
	63.9%	#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)))
	35.5%	#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 #s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)))
	3.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) (-.f64 b #s(literal 1/2 binary64))))
✓	31.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) (+.f64 (*.f64 x (log.f64 y)) z)))
✓	17.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))))
	2.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ (* x (log y)) z) t) #s(approx (+ (* x (log y)) z) (log.f64 c))))

Compiler

Compiled 2 177 to 590 computations (72.9% saved)

regimes103.0ms (2.7%)

Memory

12.5MiB live, 208.2MiB allocated

Counts

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

10.0ms	b
9.0ms	t
9.0ms	x
9.0ms	i
8.0ms	(log.f64 c)

Results

Accuracy	Segments	Branch
99.9%	1	`x`
99.9%	1	`y`
99.9%	1	`z`
99.9%	1	`t`
99.9%	1	`a`
99.9%	1	`b`
99.9%	1	`c`
99.9%	1	`i`
99.9%	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.9%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
99.9%	1	`(-.f64 b #s(literal 1/2 binary64))`
99.9%	1	`(log.f64 c)`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes100.0ms (2.6%)

Memory

18.6MiB live, 215.2MiB allocated

Counts

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

Calls

12 calls:

10.0ms	i
9.0ms	t
9.0ms	b
8.0ms	x
8.0ms	(log.f64 c)

Results

Accuracy	Segments	Branch
87.8%	3	`x`
93.6%	2	`y`
86.5%	2	`z`
95.8%	3	`t`
87.1%	2	`a`
95.2%	3	`b`
85.9%	2	`c`
93.5%	3	`i`
92.6%	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))`
95.3%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
95.2%	3	`(-.f64 b #s(literal 1/2 binary64))`
85.9%	2	`(log.f64 c)`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes41.0ms (1.1%)

Memory

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

3 calls:

23.0ms	t
8.0ms	y
7.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))

Results

Accuracy	Segments	Branch
93.6%	2	`y`
94.0%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
82.9%	1	`t`

Compiler

Compiled 8 to 28 computations (-250% saved)

regimes36.0ms (0.9%)

Memory

30.8MiB live, 69.3MiB allocated

Counts

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

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

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

Calls

5 calls:

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

Results

Accuracy	Segments	Branch
82.9%	1	`i`
92.9%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
90.8%	3	`b`
90.8%	3	`(-.f64 b #s(literal 1/2 binary64))`
87.3%	2	`y`

Compiler

Compiled 12 to 46 computations (-283.3% saved)

regimes15.0ms (0.4%)

Memory

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

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

Calls

2 calls:

7.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
6.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
82.9%	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))`
91.7%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`

Compiler

Compiled 27 to 32 computations (-18.5% saved)

regimes20.0ms (0.5%)

Memory

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

Calls

3 calls:

7.0ms	(-.f64 b #s(literal 1/2 binary64))
6.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
5.0ms	b

Results

Accuracy	Segments	Branch
88.3%	2	`b`
88.3%	2	`(-.f64 b #s(literal 1/2 binary64))`
90.3%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`

Compiler

Compiled 10 to 30 computations (-200% saved)

regimes18.0ms (0.5%)

Memory

-6.5MiB live, 30.5MiB allocated

Counts

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

Outputs

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

Calls

3 calls:

5.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
5.0ms	b
4.0ms	(-.f64 b #s(literal 1/2 binary64))

Results

Accuracy	Segments	Branch
87.9%	2	`b`
87.9%	2	`(-.f64 b #s(literal 1/2 binary64))`
89.6%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`

Compiler

Compiled 10 to 30 computations (-200% saved)

regimes68.0ms (1.8%)

Memory

-5.9MiB live, 113.1MiB allocated

Counts

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

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

Calls

12 calls:

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))
9.0ms	(log.f64 c)
9.0ms	b
4.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
4.0ms	y

Results

Accuracy	Segments	Branch
75.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))`
72.2%	3	`t`
76.4%	3	`i`
68.0%	1	`c`
68.0%	1	`(log.f64 c)`
68.0%	1	`x`
69.6%	2	`z`
76.4%	3	`a`
76.5%	2	`y`
76.0%	3	`b`
76.0%	3	`(-.f64 b #s(literal 1/2 binary64))`
75.7%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes33.0ms (0.9%)

Memory

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

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

Calls

7 calls:

9.0ms	b
4.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	y
4.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))

Results

Accuracy	Segments	Branch
75.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))`
74.3%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
74.0%	3	`(-.f64 b #s(literal 1/2 binary64))`
74.0%	3	`b`
68.4%	3	`a`
72.6%	3	`i`
70.8%	2	`y`

Compiler

Compiled 34 to 74 computations (-117.6% saved)

regimes8.0ms (0.2%)

Memory

-26.8MiB live, 11.1MiB allocated

Counts

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

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

Calls

1 calls:

7.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
75.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))`

Compiler

Compiled 21 to 20 computations (4.8% saved)

regimes45.0ms (1.2%)

Memory

0.2MiB live, 83.1MiB allocated

Counts

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

Calls

12 calls:

6.0ms	a
5.0ms	y
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	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
3.0ms	(log.f64 c)

Results

Accuracy	Segments	Branch
52.9%	4	`a`
50.2%	3	`c`
50.2%	3	`(log.f64 c)`
54.7%	4	`x`
51.9%	3	`z`
61.5%	3	`t`
57.7%	3	`y`
52.8%	3	`i`
56.0%	3	`(-.f64 b #s(literal 1/2 binary64))`
56.0%	3	`b`
55.6%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
62.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))`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes35.0ms (0.9%)

Memory

30.0MiB live, 68.7MiB allocated

Counts

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

Calls

12 calls:

5.0ms	x
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	y
3.0ms	(log.f64 c)
3.0ms	t

Results

Accuracy	Segments	Branch
37.5%	2	`c`
37.5%	2	`(log.f64 c)`
35.5%	1	`a`
46.0%	3	`z`
39.4%	2	`i`
46.6%	3	`x`
43.6%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
43.2%	3	`(-.f64 b #s(literal 1/2 binary64))`
43.2%	3	`b`
37.4%	2	`y`
38.5%	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))`
47.4%	3	`t`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes19.0ms (0.5%)

Memory

-2.4MiB live, 36.2MiB allocated

Counts

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

Outputs

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

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

Calls

7 calls:

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

Results

Accuracy	Segments	Branch
31.8%	1	`i`
40.7%	3	`b`
40.7%	3	`(-.f64 b #s(literal 1/2 binary64))`
40.7%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
31.8%	1	`z`
35.6%	3	`x`
31.8%	1	`t`

Compiler

Compiled 14 to 62 computations (-342.9% saved)

regimes33.0ms (0.9%)

Memory

-32.3MiB live, 53.1MiB allocated

Counts

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

Calls

12 calls:

7.0ms	z
4.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))
2.0ms	(log.f64 c)

Results

Accuracy	Segments	Branch
20.0%	2	`z`
22.0%	3	`i`
19.6%	2	`t`
28.4%	3	`x`
21.0%	2	`a`
20.7%	2	`y`
17.5%	1	`c`
17.5%	1	`(log.f64 c)`
20.6%	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))`
28.1%	3	`b`
28.1%	3	`(-.f64 b #s(literal 1/2 binary64))`
28.0%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes24.0ms (0.6%)

Memory

11.5MiB live, 49.7MiB allocated

Counts

3 → 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) (-.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) #s(approx (+ (* x (log y)) z) (log.f64 c))))

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

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

Calls

12 calls:

4.0ms	t
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))
2.0ms	(log.f64 c)
2.0ms	a

Results

Accuracy	Segments	Branch
16.7%	1	`c`
16.7%	1	`(log.f64 c)`
16.7%	1	`t`
16.7%	1	`z`
16.7%	1	`i`
16.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))`
16.7%	1	`y`
16.7%	1	`a`
16.7%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
16.7%	1	`b`
16.7%	1	`(-.f64 b #s(literal 1/2 binary64))`
16.7%	1	`x`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes21.0ms (0.5%)

Memory

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

Calls

12 calls:

4.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))
1.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
1.0ms	x
1.0ms	a

Results

Accuracy	Segments	Branch
3.3%	1	`i`
3.3%	1	`t`
3.3%	1	`a`
3.3%	1	`x`
3.3%	1	`b`
3.3%	1	`(-.f64 b #s(literal 1/2 binary64))`
3.3%	1	`z`
3.3%	1	`c`
3.3%	1	`(log.f64 c)`
3.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))`
3.3%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
3.3%	1	`y`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

bsearch52.0ms (1.4%)

Memory

-7.0MiB live, 74.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
30.0ms	4.525807194343127e+140	2.403117906219611e+152
17.0ms	-6.128428660009247e+156	-3.617927693149893e+155

Samples

36.0ms

272×

valid

Compiler

Compiled 1 030 to 908 computations (11.8% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch17.0ms (0.4%)

Memory

24.7MiB live, 24.6MiB allocated

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
15.0ms	2.7159234589837885e+89	1.613408092254431e+90

Samples

11.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 (28.7% of total)

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

ival-mult: 2.0ms (28.7% 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.3MiB live, 1.3MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	7.020707597041756e+248	1.1681439885450663e+250
0.0ms	-3.9579519894923454e+146	-2.587199126650278e+142

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	7.020707597041756e+248	1.1681439885450663e+250
0.0ms	-4.385894268519458e+171	-7.320099280345619e+164

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	7.020707597041756e+248	1.1681439885450663e+250
0.0ms	-2.0829512397649708e+179	-2.622304691684967e+178

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch4.0ms (0.1%)

Memory

-36.8MiB live, 1.1MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	2.0998533303830843e+248	7.020707597041756e+248
3.0ms	-2.0829512397649708e+179	-2.622304691684967e+178

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch14.0ms (0.4%)

Memory

22.0MiB live, 22.0MiB allocated

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
12.0ms	9.524025392370205e+65	2.4912696839566936e+66

Samples

9.0ms

80×

valid

Compiler

Compiled 424 to 301 computations (29% saved)

Precisions

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

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

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

ival-mult: 2.0ms (34.6% 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.7MiB live, 1.7MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	4.959801952601178e+304	2.1719890759244958e+307
0.0ms	-inf	-1.7061136711903702e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

1.4MiB live, 1.4MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	3.6232061968246284e+307	+inf
0.0ms	-inf	-1.7061136711903702e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch52.0ms (1.3%)

Memory

-0.2MiB live, 76.1MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
19.0ms	6.58197539221888e+175	1.3785922510551185e+178
28.0ms	-9.601940268173489e+145	-1.6424981786997153e+131

Samples

32.0ms

272×

valid

Compiler

Compiled 1 622 to 983 computations (39.4% saved)

Precisions

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

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

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

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

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

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

exact: 0.0ms (0% of total)

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

bsearch49.0ms (1.3%)

Memory

-3.6MiB live, 79.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
17.0ms	6.58197539221888e+175	1.3785922510551185e+178
28.0ms	-7.070300600713279e+75	-1.853419496031451e+65

Samples

34.0ms

256×

valid

Compiler

Compiled 1 588 to 966 computations (39.2% saved)

Precisions

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

ival-add: 10.0ms (43.9% of total)

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

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

ival-sub: 1.0ms (4.4% 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.3MiB live, 1.3MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	2.7380861635530104e+212	1.7525957675828942e+213
0.0ms	-2.0829512397649708e+179	-2.622304691684967e+178

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch46.0ms (1.2%)

Memory

-11.6MiB live, 64.8MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
20.0ms	7.365155485267679e+209	1.5541417807315649e+212
22.0ms	-6.072371188430985e+31	-1.0541061367814039e+28

Samples

29.0ms

240×

valid

Compiler

Compiled 1 074 to 811 computations (24.5% saved)

Precisions

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

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

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

ival-mult: 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)

simplify5.0ms (0.1%)

Memory: 11.3MiB live, 11.3MiB allocated

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze21.0ms (0.5%)

sample1.5s (38%)

explain337.0ms (8.8%)

preprocess7.0ms (0.2%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify1.0ms (0%)

localize48.0ms (1.3%)

series247.0ms (6.4%)

simplify1.0ms (0%)

rewrite0.0ms (0%)

eval2.0ms (0%)

prune5.0ms (0.1%)

simplify2.0ms (0%)

localize85.0ms (2.2%)

series204.0ms (5.3%)

simplify4.0ms (0.1%)

rewrite1.0ms (0%)

eval7.0ms (0.2%)

prune7.0ms (0.2%)

simplify5.0ms (0.1%)

localize79.0ms (2%)

series167.0ms (4.3%)

simplify2.0ms (0%)

rewrite1.0ms (0%)

eval8.0ms (0.2%)

prune10.0ms (0.3%)

simplify2.0ms (0.1%)

localize74.0ms (1.9%)

series173.0ms (4.5%)

simplify2.0ms (0%)

rewrite1.0ms (0%)

eval8.0ms (0.2%)

prune15.0ms (0.4%)

regimes103.0ms (2.7%)

regimes100.0ms (2.6%)

regimes41.0ms (1.1%)

regimes36.0ms (0.9%)

regimes15.0ms (0.4%)

regimes20.0ms (0.5%)

regimes18.0ms (0.5%)

regimes68.0ms (1.8%)

regimes33.0ms (0.9%)

regimes8.0ms (0.2%)

regimes45.0ms (1.2%)

regimes35.0ms (0.9%)

regimes19.0ms (0.5%)

regimes33.0ms (0.9%)

regimes24.0ms (0.6%)

regimes21.0ms (0.5%)

bsearch52.0ms (1.4%)

bsearch17.0ms (0.4%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch4.0ms (0.1%)

bsearch14.0ms (0.4%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch52.0ms (1.3%)

bsearch49.0ms (1.3%)

bsearch1.0ms (0%)

bsearch46.0ms (1.2%)

simplify5.0ms (0.1%)

end0.0ms (0%)

Profiling