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

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze43.0ms (1.3%)

Memory

-4.6MiB live, 70.1MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.7%	0.3%	0%	0%	0%	0
0%	0%	99.7%	0.3%	0%	0%	0%	1
0%	0%	99.7%	0.3%	0%	0%	0%	2
0%	0%	99.7%	0.3%	0%	0%	0%	3
0%	0%	49.9%	0.3%	0%	49.9%	0%	4
0%	0%	49.9%	0.3%	0%	49.9%	0%	5
50%	12.5%	12.5%	0.3%	0%	74.8%	0%	6
50%	12.5%	12.5%	0.3%	0%	74.8%	0%	7
50%	12.5%	12.5%	0.3%	0%	74.8%	0%	8
75%	18.7%	6.2%	0.3%	0%	74.8%	0%	9
75%	18.7%	6.2%	0.3%	0%	74.8%	0%	10
75%	18.7%	6.2%	0.3%	0%	74.8%	0%	11
75%	18.7%	6.2%	0.3%	0%	74.8%	0%	12

Compiler

Compiled 20 to 19 computations (5% saved)

sample1.4s (39.8%)

Memory

14.3MiB live, 2 292.7MiB allocated

Samples

951.0ms

8 256×

valid

Precisions

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

ival-log: 235.0ms (35.2% of total)

ival-mult: 183.0ms (27.4% of total)

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

ival-exp: 62.0ms (9.3% of total)

ival-div: 54.0ms (8.1% of total)

ival-add: 40.0ms (6% of total)

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

exact: 5.0ms (0.7% of total)

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

Bogosity

explain181.0ms (5.3%)

Memory

-13.3MiB live, 349.3MiB allocated

FPErrors

Click to see full error table

Ground Truth	Overpredictions	Example	Underpredictions	Example	Subexpression
25	5	(-2.366125292382141e+213 -3.5260570159386526e-124 1.7401232098685652e-226 7.491181533093268e-153 7.872211603929475e-196 1.0833382515923779e-16)	2	(2.0121114866307666e-217 3.7316741524553915e-174 1.547818705989914e+219 2.1559192621545993e-300 2798812239737266.5 1.7689038583293412e-245)	`(exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))`
3	0	-	0	-	`(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)`
0	0	-	0	-	`(+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)))`
0	0	-	0	-	`a`
0	0	-	0	-	`t`
0	0	-	0	-	`#s(literal 1 binary64)`
0	0	-	0	-	`(log.f64 z)`
0	0	-	0	-	`(.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))`
0	0	-	0	-	`(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))`
0	0	-	0	-	`(log.f64 a)`
0	0	-	0	-	`y`
0	0	-	0	-	`(*.f64 y (log.f64 z))`
0	0	-	0	-	`(-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)`
0	0	-	0	-	`z`
0	0	-	0	-	`(-.f64 t #s(literal 1 binary64))`
0	0	-	0	-	`b`
0	0	-	0	-	`x`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`exp.f64`	`(exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))`	sensitivity	28	3
`/.f64`	`(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)`	u/n	3	0
↳	`(.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))`	underflow	121
↳	`(exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))`	underflow	118

Confusion

	Predicted +	Predicted -
+	16	1
-	12	227

Precision

0.5714285714285714

Recall

0.9411764705882353

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	16	1	0
-	12	2	225

Precision?

0.5483870967741935

Recall?

1.0

Freqs

test

number	freq
0	228
1	25
2	3

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

64.0ms

512×

valid

Compiler

Compiled 310 to 72 computations (76.8% saved)

Precisions

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

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

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

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

ival-exp: 4.0ms (10.9% of total)

ival-div: 3.0ms (8.2% of total)

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

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

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

exact: 0.0ms (0% of total)

preprocess5.0ms (0.1%)

Memory

8.6MiB live, 8.6MiB allocated

Algorithm

1×	egg-herbie

Calls

Call 1

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

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

Compiler

Compiled 18 to 17 computations (5.6% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

0.8MiB live, 0.8MiB allocated

Alt Table

Click to see full alt table

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

Compiler

Compiled 18 to 17 computations (5.6% saved)

simplify1.0ms (0%)

Memory

0.9MiB live, 1.0MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

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

Calls

Call 1

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

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

localize44.0ms (1.3%)

Memory

-12.7MiB live, 63.3MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.16796875	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
accuracy	0.296875	(*.f64 y (log.f64 z))
accuracy	0.6673660253377923	(exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
accuracy	0.6975322650453475	(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)

Samples

33.0ms

256×

valid

Compiler

Compiled 194 to 36 computations (81.4% saved)

Precisions

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

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

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

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

ival-exp: 2.0ms (9.7% of total)

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

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

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

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

exact: 0.0ms (0% of total)

series261.0ms (7.6%)

Memory

28.7MiB live, 454.1MiB allocated

Counts

6 → 85

Calls

Call 1

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

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

Calls

18 calls:

Time	Variable		Point	Expression
57.0ms	x	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (* y (log z)) (* (- t 1) (log a)))
34.0ms	z	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (* y (log z)) (* (- t 1) (log a)))
22.0ms	z	@	-inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (* y (log z)) (* (- t 1) (log a)))
18.0ms	a	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (* y (log z)) (* (- t 1) (log a)))
16.0ms	z	@	inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (* y (log z)) (* (- t 1) (log a)))

simplify2.0ms (0%)

Memory

2.8MiB live, 2.8MiB allocated

Algorithm

1×	egg-herbie

Counts

85 → 6

Calls

Call 1

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

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

rewrite0.0ms (0%)

Memory

0.8MiB live, 0.8MiB allocated

Counts

6 → 6

Calls

Call 1

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

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

eval1.0ms (0%)

Memory: 2.5MiB live, 2.5MiB allocated
Compiler: Compiled 293 to 35 computations (88.1% saved)

prune2.0ms (0.1%)

Memory

5.4MiB live, 5.4MiB allocated

Pruning

5 alts after pruning (4 fresh and 1 done)

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

Accuracy

98.3%

Counts

13 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	98.3%	(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)
▶	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
▶	2.5%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)))
▶	3.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 y (log.f64 z)))
▶	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))

Compiler

Compiled 131 to 112 computations (14.5% saved)

simplify1.0ms (0%)

Memory

2.1MiB live, 2.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 15 expressions of interest:

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

Calls

Call 1

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

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

localize62.0ms (1.8%)

Memory

9.3MiB live, 90.3MiB allocated

Localize:

Found 15 expressions of interest:

New	Metric	Score
accuracy	0.015625	(-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)
accuracy	0.16796875	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
accuracy	0.296875	(*.f64 y (log.f64 z))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
accuracy	0.0	(-.f64 t #s(literal 1 binary64))
accuracy	0.0	(log.f64 a)
accuracy	0.16796875	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
accuracy	62.422067408970314	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)))
accuracy	0.0	(log.f64 z)
accuracy	0.296875	(*.f64 y (log.f64 z))
accuracy	61.8064514813608	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 y (log.f64 z)))
accuracy	0.16796875	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
accuracy	0.296875	(*.f64 y (log.f64 z))
accuracy	0.6673660253377923	(exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
accuracy	21.514649560357753	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))

Samples

47.0ms

256×

valid

Compiler

Compiled 447 to 49 computations (89% saved)

Precisions

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

ival-sub: 12.0ms (40.3% of total)

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

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

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

ival-exp: 2.0ms (6.7% of total)

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

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

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

exact: 0.0ms (0% of total)

series183.0ms (5.4%)

Memory

-16.8MiB live, 375.4MiB allocated

Counts

12 → 87

Calls

Call 1

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

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

Calls

18 calls:

Time	Variable		Point	Expression
19.0ms	x	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* (- t 1) (log a)) (- t 1) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y))
15.0ms	a	@	inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* (- t 1) (log a)) (- t 1) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y))
15.0ms	z	@	inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* (- t 1) (log a)) (- t 1) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y))
14.0ms	a	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* (- t 1) (log a)) (- t 1) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y))
14.0ms	x	@	-inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* (- t 1) (log a)) (- t 1) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y))

simplify1.0ms (0%)

Memory

2.6MiB live, 2.6MiB allocated

Algorithm

1×	egg-herbie

Counts

87 → 12

Calls

Call 1

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

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

rewrite1.0ms (0%)

Memory

1.3MiB live, 1.3MiB allocated

Counts

12 → 12

Calls

Call 1

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

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

eval4.0ms (0.1%)

Memory: 7.7MiB live, 7.7MiB allocated
Compiler: Compiled 1 294 to 54 computations (95.8% saved)

prune11.0ms (0.3%)

Memory

-19.1MiB live, 19.9MiB allocated

Pruning

13 alts after pruning (8 fresh and 5 done)

	Pruned	Kept	Total
New	29	8	37
Fresh	0	0	0
Picked	0	4	4
Done	0	1	1
Total	29	13	42

Accuracy

98.3%

Counts

42 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	98.3%	(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)
✓	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
▶	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))
	2.9%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))))
✓	2.5%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)))
✓	3.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 y (log.f64 z)))
✓	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
▶	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))
	25.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64)))))
▶	2.9%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))
▶	2.7%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))
▶	2.6%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))
	2.6%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log.f64 z)))

Compiler

Compiled 813 to 488 computations (40% saved)

simplify2.0ms (0.1%)

Memory

3.5MiB live, 3.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 18 expressions of interest:

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

Calls

Call 1

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

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

localize59.0ms (1.7%)

Memory

26.6MiB live, 105.8MiB allocated

Localize:

Found 18 expressions of interest:

New	Metric	Score
accuracy	0.296875	(*.f64 y (log.f64 z))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))
accuracy	62.141656758641936	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
accuracy	0.0	(log.f64 a)
accuracy	0.6673660253377923	(exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))
accuracy	21.514649560357753	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))
accuracy	62.23735625317469	#s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))
accuracy	0.0	(log.f64 a)
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))
accuracy	62.23735625317469	#s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))
accuracy	0.0	(-.f64 t #s(literal 1 binary64))
accuracy	60.37013689579327	#s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64)))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))
accuracy	0.6673660253377923	(exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))
accuracy	21.514649560357753	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
accuracy	62.141656758641936	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))

Samples

40.0ms

256×

valid

Compiler

Compiled 1 048 to 56 computations (94.7% saved)

Precisions

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

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

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

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

ival-exp: 2.0ms (10.4% of total)

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

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

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

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

exact: 0.0ms (0% of total)

series212.0ms (6.2%)

Memory

-14.4MiB live, 338.1MiB allocated

Counts

15 → 78

Calls

Call 1

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

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

Calls

18 calls:

Time	Variable		Point	Expression
22.0ms	x	@	-inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (- t 1) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)))
21.0ms	x	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (- t 1) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)))
18.0ms	z	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (- t 1) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)))
17.0ms	a	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (- t 1) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)))
17.0ms	a	@	inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (- t 1) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log a) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (* y (log z)))

simplify2.0ms (0%)

Memory

2.5MiB live, 2.5MiB allocated

Algorithm

1×	egg-herbie

Counts

78 → 15

Calls

Call 1

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

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

rewrite1.0ms (0%)

Memory

1.9MiB live, 1.9MiB allocated

Counts

15 → 15

Calls

Call 1

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

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

eval4.0ms (0.1%)

Memory: 7.9MiB live, 7.9MiB allocated
Compiler: Compiled 2 422 to 73 computations (97% saved)

prune18.0ms (0.5%)

Memory

-14.3MiB live, 23.1MiB allocated

Pruning

17 alts after pruning (8 fresh and 9 done)

	Pruned	Kept	Total
New	36	5	41
Fresh	0	3	3
Picked	0	5	5
Done	1	4	5
Total	37	17	54

Accuracy

98.3%

Counts

54 → 17

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	98.3%	(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)
▶	2.7%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b))
✓	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))
▶	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b))
	2.9%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))))
✓	2.5%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)))
✓	3.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 y (log.f64 z)))
✓	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
▶	31.5%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b)))
✓	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))
▶	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b)))
	25.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64)))))
✓	2.9%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))
	12.2%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))))))
✓	2.7%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))
✓	2.6%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))
▶	2.6%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log.f64 z)))

Compiler

Compiled 1 279 to 613 computations (52.1% saved)

simplify3.0ms (0.1%)

Memory

5.2MiB live, 5.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

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

Calls

Call 1

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

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

localize73.0ms (2.1%)

Memory

20.9MiB live, 101.2MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score
accuracy	0.6673660253377923	(exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))
accuracy	21.514649560357753	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b)))
accuracy	61.5009254092164	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))
accuracy	62.23735625317469	#s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b))
accuracy	62.141656758641936	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
accuracy	62.141656758641936	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))
accuracy	0.6673660253377923	(exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))
accuracy	61.5009254092164	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b))
accuracy	62.23735625317469	#s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))
accuracy	0.0	(log.f64 z)
accuracy	21.514649560357753	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log.f64 z)))
accuracy	62.32873514896474	#s(approx (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log.f64 z))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))
accuracy	62.08519172797787	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))
accuracy	62.141656758641936	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
accuracy	62.141656758641936	#s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))

Samples

43.0ms

256×

valid

Compiler

Compiled 1 949 to 62 computations (96.8% saved)

Precisions

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

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

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

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

ival-exp: 2.0ms (9.5% of total)

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

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

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

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

exact: 0.0ms (0% of total)

series234.0ms (6.8%)

Memory

-24.5MiB live, 349.0MiB allocated

Counts

18 → 71

Calls

Call 1

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

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

Calls

18 calls:

Time	Variable		Point	Expression
25.0ms	x	@	-inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b))
24.0ms	z	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b))
21.0ms	x	@	0	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b))
20.0ms	x	@	inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b))
20.0ms	z	@	-inf	((/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log z) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b) (+ (* y (log z)) (* (- t 1) (log a))) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (+ (* y (log z)) (* (- t 1) (log a))) (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (- (+ (* y (log z)) (* (- t 1) (log a))) b))

simplify2.0ms (0.1%)

Memory

5.7MiB live, 5.7MiB allocated

Algorithm

1×	egg-herbie

Counts

71 → 18

Calls

Call 1

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

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

rewrite2.0ms (0%)

Memory

4.7MiB live, 4.7MiB allocated

Counts

18 → 18

Calls

Call 1

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

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

eval8.0ms (0.2%)

Memory: -21.4MiB live, 17.2MiB allocated
Compiler: Compiled 3 504 to 81 computations (97.7% saved)

prune16.0ms (0.5%)

Memory

6.5MiB live, 52.2MiB allocated

Pruning

19 alts after pruning (5 fresh and 14 done)

	Pruned	Kept	Total
New	45	3	48
Fresh	1	2	3
Picked	0	5	5
Done	0	9	9
Total	46	19	65

Accuracy

98.3%

Counts

65 → 19

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	98.3%	(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)
✓	2.7%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b))
✓	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))
✓	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b))
	3.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b))) b))
	2.9%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))))
✓	2.5%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)))
✓	3.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (*.f64 y (log.f64 z)))
✓	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
✓	31.5%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b)))
✓	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))
✓	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b)))
	66.4%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b))) b)))
	25.0%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64)))))
✓	2.9%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))
	12.2%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))))
✓	2.7%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))
✓	2.6%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))
✓	2.6%	#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b)) (log.f64 z)))

Compiler

Compiled 2 206 to 549 computations (75.1% saved)

regimes81.0ms (2.4%)

Memory

-19.2MiB live, 178.1MiB allocated

Counts

21 → 1

Calls

Call 1

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

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

Calls

11 calls:

9.0ms	z
8.0ms	b
8.0ms	(log.f64 z)
8.0ms	(log.f64 a)
7.0ms	t

Results

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

Compiler

Compiled 37 to 85 computations (-129.7% saved)

regimes75.0ms (2.2%)

Memory

22.0MiB live, 141.2MiB allocated

Counts

20 → 1

Calls

Call 1

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

Outputs

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

Calls

11 calls:

8.0ms	y
8.0ms	(log.f64 z)
7.0ms	a
7.0ms	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
7.0ms	t

Results

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

Compiler

Compiled 37 to 85 computations (-129.7% saved)

regimes71.0ms (2.1%)

Memory

14.6MiB live, 132.1MiB allocated

Counts

19 → 1

Calls

Call 1

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

Outputs

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

Calls

11 calls:

7.0ms	(log.f64 a)
7.0ms	z
7.0ms	b
6.0ms	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
6.0ms	t

Results

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

Compiler

Compiled 37 to 85 computations (-129.7% saved)

regimes74.0ms (2.2%)

Memory

-28.6MiB live, 88.6MiB allocated

Counts

18 → 1

Calls

Call 1

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

Outputs

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

Calls

11 calls:

9.0ms	x
9.0ms	(log.f64 a)
8.0ms	z
6.0ms	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
6.0ms	t

Results

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

Compiler

Compiled 37 to 85 computations (-129.7% saved)

regimes71.0ms (2.1%)

Memory

10.2MiB live, 90.6MiB allocated

Counts

17 → 1

Calls

Call 1

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

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

Calls

11 calls:

10.0ms	t
10.0ms	(log.f64 z)
6.0ms	x
6.0ms	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
6.0ms	a

Results

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

Compiler

Compiled 37 to 85 computations (-129.7% saved)

regimes64.0ms (1.9%)

Memory

11.4MiB live, 87.3MiB allocated

Counts

16 → 2

Calls

Call 1

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

Outputs

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

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

Calls

11 calls:

8.0ms	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
8.0ms	t
5.0ms	y
5.0ms	a
5.0ms	(log.f64 z)

Results

Accuracy	Segments	Branch
35.1%	2	`x`
42.7%	2	`t`
40.8%	3	`b`
34.9%	2	`(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)`
42.7%	2	`(-.f64 t #s(literal 1 binary64))`
33.5%	2	`z`
33.5%	2	`(log.f64 z)`
43.0%	2	`(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))`
36.7%	2	`a`
36.7%	2	`(log.f64 a)`
31.5%	1	`y`

Compiler

Compiled 37 to 85 computations (-129.7% saved)

regimes60.0ms (1.8%)

Memory

7.9MiB live, 128.6MiB allocated

Counts

15 → 2

Calls

Call 1

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

Outputs

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

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

Calls

11 calls:

6.0ms	(log.f64 z)
6.0ms	(-.f64 t #s(literal 1 binary64))
5.0ms	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
5.0ms	a
5.0ms	t

Results

Accuracy	Segments	Branch
25.0%	1	`y`
25.0%	1	`z`
25.0%	1	`(log.f64 z)`
28.9%	2	`(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)`
25.0%	1	`x`
25.0%	1	`a`
25.0%	1	`(log.f64 a)`
26.9%	2	`b`
26.8%	2	`t`
26.8%	2	`(-.f64 t #s(literal 1 binary64))`
28.3%	3	`(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))`

Compiler

Compiled 37 to 85 computations (-129.7% saved)

regimes25.0ms (0.7%)

Memory

7.1MiB live, 45.0MiB allocated

Counts

13 → 1

Calls

Call 1

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

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

Calls

5 calls:

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

Results

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

Compiler

Compiled 29 to 47 computations (-62.1% saved)

regimes26.0ms (0.8%)

Memory

-32.0MiB live, 47.6MiB allocated

Accuracy

Total -0.6b remaining (-0.9%)

Threshold costs -0.6b (-0.9%)

Counts

3 → 1

Calls

Call 1

Inputs

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

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

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

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

Calls

11 calls:

7.0ms	(*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))
3.0ms	b
2.0ms	(log.f64 z)
2.0ms	(log.f64 a)
2.0ms	t

Results

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

Compiler

Compiled 37 to 85 computations (-129.7% saved)

bsearch1.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-2.69844688960653e+36	-4.408134873767193e+35

Compiler

Compiled 21 to 26 computations (-23.8% saved)

bsearch0.0ms (0%)

Memory

0.9MiB live, 0.9MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	1.2116177477926664e+147	3.516773151903816e+237

Compiler

Compiled 21 to 26 computations (-23.8% saved)

simplify6.0ms (0.2%)

Memory

12.8MiB live, 12.8MiB allocated

Algorithm

1×	egg-herbie

Calls

Call 1

Inputs
(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b))) b)))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b)))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
(if (<=.f64 (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) #s(literal -2000000000000000084841274748035923968 binary64)) #s(approx (/ ( x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b))))
(if (<=.f64 (/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) #s(literal 1999999999999999955992764811315320348729647778935602161544506489938527878458214984853852098846521027939536536831074154937676864613462292790727671808 binary64)) #s(approx (/ ( x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))))))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64)))))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))

Outputs
(/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y)
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b))) b)))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b))) b)))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) b)))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b)))
(if (<=.f64 (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) #s(literal -2000000000000000084841274748035923968 binary64)) #s(approx (/ ( x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 (-.f64 #s(approx (+ (* y (log z)) (* (- t 1) (log a))) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a)))) b))))
(if (<=.f64 (/.f64 (.f64 x (exp.f64 (-.f64 (+.f64 (.f64 y (log.f64 z)) (.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a))) b))) y) #s(literal 1999999999999999955992764811315320348729647778935602161544506489938527878458214984853852098846521027939536536831074154937676864613462292790727671808 binary64)) #s(approx (/ ( x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) #s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (log.f64 a))))))))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) (exp.f64 #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64)))))
#s(approx (/ (* x (exp (- (+ (* y (log z)) (* (- t 1) (log a))) b))) y) #s(approx (- (+ (* y (log z)) (* (- t 1) (log a))) b) (-.f64 t #s(literal 1 binary64))))

soundness2.0ms (0.1%)

Memory

5.0MiB live, 5.0MiB allocated

Stop Event

1×

fuel

Compiler

Compiled 646 to 64 computations (90.1% saved)

preprocess62.0ms (1.8%)

Memory: 23.0MiB live, 97.5MiB allocated
Compiler: Compiled 1 450 to 218 computations (85% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze43.0ms (1.3%)

sample1.4s (39.8%)

explain181.0ms (5.3%)

preprocess5.0ms (0.1%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify1.0ms (0%)

localize44.0ms (1.3%)

series261.0ms (7.6%)

simplify2.0ms (0%)

rewrite0.0ms (0%)

eval1.0ms (0%)

prune2.0ms (0.1%)

simplify1.0ms (0%)

localize62.0ms (1.8%)

series183.0ms (5.4%)

simplify1.0ms (0%)

rewrite1.0ms (0%)

eval4.0ms (0.1%)

prune11.0ms (0.3%)

simplify2.0ms (0.1%)

localize59.0ms (1.7%)

series212.0ms (6.2%)

simplify2.0ms (0%)

rewrite1.0ms (0%)

eval4.0ms (0.1%)

prune18.0ms (0.5%)

simplify3.0ms (0.1%)

localize73.0ms (2.1%)

series234.0ms (6.8%)

simplify2.0ms (0.1%)

rewrite2.0ms (0%)

eval8.0ms (0.2%)

prune16.0ms (0.5%)

regimes81.0ms (2.4%)

regimes75.0ms (2.2%)

regimes71.0ms (2.1%)

regimes74.0ms (2.2%)

regimes71.0ms (2.1%)

regimes64.0ms (1.9%)

regimes60.0ms (1.8%)

regimes25.0ms (0.7%)

regimes26.0ms (0.8%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

simplify6.0ms (0.2%)

soundness2.0ms (0.1%)

preprocess62.0ms (1.8%)

end0.0ms (0%)

Profiling