
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}
\end{array}
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (+ t -1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t + (-1.0d0)) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t + -1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t + -1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t + -1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t + -1\right) \cdot \log a\right) - b}}{y}
\end{array}
Initial program 99.0%
Final simplification99.0%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -1.45e+87) (not (<= y 1.5e+60))) (* x (/ (exp (- (- (* y (log z)) (log a)) b)) y)) (/ (* x (exp (- (* (+ t -1.0) (log a)) b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -1.45e+87) || !(y <= 1.5e+60)) {
tmp = x * (exp((((y * log(z)) - log(a)) - b)) / y);
} else {
tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-1.45d+87)) .or. (.not. (y <= 1.5d+60))) then
tmp = x * (exp((((y * log(z)) - log(a)) - b)) / y)
else
tmp = (x * exp((((t + (-1.0d0)) * log(a)) - b))) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -1.45e+87) || !(y <= 1.5e+60)) {
tmp = x * (Math.exp((((y * Math.log(z)) - Math.log(a)) - b)) / y);
} else {
tmp = (x * Math.exp((((t + -1.0) * Math.log(a)) - b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -1.45e+87) or not (y <= 1.5e+60): tmp = x * (math.exp((((y * math.log(z)) - math.log(a)) - b)) / y) else: tmp = (x * math.exp((((t + -1.0) * math.log(a)) - b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -1.45e+87) || !(y <= 1.5e+60)) tmp = Float64(x * Float64(exp(Float64(Float64(Float64(y * log(z)) - log(a)) - b)) / y)); else tmp = Float64(Float64(x * exp(Float64(Float64(Float64(t + -1.0) * log(a)) - b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -1.45e+87) || ~((y <= 1.5e+60))) tmp = x * (exp((((y * log(z)) - log(a)) - b)) / y); else tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -1.45e+87], N[Not[LessEqual[y, 1.5e+60]], $MachinePrecision]], N[(x * N[(N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] - N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[Exp[N[(N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.45 \cdot 10^{+87} \lor \neg \left(y \leq 1.5 \cdot 10^{+60}\right):\\
\;\;\;\;x \cdot \frac{e^{\left(y \cdot \log z - \log a\right) - b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\left(t + -1\right) \cdot \log a - b}}{y}\\
\end{array}
\end{array}
if y < -1.4499999999999999e87 or 1.4999999999999999e60 < y Initial program 100.0%
*-commutative100.0%
associate-/l*86.8%
associate--l+86.8%
fma-define86.8%
sub-neg86.8%
metadata-eval86.8%
Simplified86.8%
Taylor expanded in t around 0 93.5%
associate-/l*93.5%
+-commutative93.5%
mul-1-neg93.5%
unsub-neg93.5%
Simplified93.5%
if -1.4499999999999999e87 < y < 1.4999999999999999e60Initial program 98.4%
*-commutative98.4%
associate-/l*90.7%
associate--l+90.7%
fma-define90.7%
sub-neg90.7%
metadata-eval90.7%
Simplified90.7%
Taylor expanded in y around 0 94.6%
Final simplification94.2%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -5.4e+101) (not (<= y 9.5e+94))) (* x (/ (/ (pow z y) a) y)) (/ (* x (exp (- (* (+ t -1.0) (log a)) b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -5.4e+101) || !(y <= 9.5e+94)) {
tmp = x * ((pow(z, y) / a) / y);
} else {
tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-5.4d+101)) .or. (.not. (y <= 9.5d+94))) then
tmp = x * (((z ** y) / a) / y)
else
tmp = (x * exp((((t + (-1.0d0)) * log(a)) - b))) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -5.4e+101) || !(y <= 9.5e+94)) {
tmp = x * ((Math.pow(z, y) / a) / y);
} else {
tmp = (x * Math.exp((((t + -1.0) * Math.log(a)) - b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -5.4e+101) or not (y <= 9.5e+94): tmp = x * ((math.pow(z, y) / a) / y) else: tmp = (x * math.exp((((t + -1.0) * math.log(a)) - b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -5.4e+101) || !(y <= 9.5e+94)) tmp = Float64(x * Float64(Float64((z ^ y) / a) / y)); else tmp = Float64(Float64(x * exp(Float64(Float64(Float64(t + -1.0) * log(a)) - b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -5.4e+101) || ~((y <= 9.5e+94))) tmp = x * (((z ^ y) / a) / y); else tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -5.4e+101], N[Not[LessEqual[y, 9.5e+94]], $MachinePrecision]], N[(x * N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[Exp[N[(N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.4 \cdot 10^{+101} \lor \neg \left(y \leq 9.5 \cdot 10^{+94}\right):\\
\;\;\;\;x \cdot \frac{\frac{{z}^{y}}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\left(t + -1\right) \cdot \log a - b}}{y}\\
\end{array}
\end{array}
if y < -5.40000000000000012e101 or 9.4999999999999998e94 < y Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum68.7%
associate-/l*61.4%
*-commutative61.4%
exp-to-pow61.4%
exp-diff56.6%
*-commutative56.6%
exp-to-pow56.6%
sub-neg56.6%
metadata-eval56.6%
Simplified56.6%
Taylor expanded in t around 0 56.7%
associate-/r*68.8%
Simplified68.8%
Taylor expanded in b around 0 91.7%
if -5.40000000000000012e101 < y < 9.4999999999999998e94Initial program 98.5%
*-commutative98.5%
associate-/l*91.2%
associate--l+91.2%
fma-define91.2%
sub-neg91.2%
metadata-eval91.2%
Simplified91.2%
Taylor expanded in y around 0 93.2%
Final simplification92.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -18000000000.0)
(/ (* x (pow a (+ t -1.0))) y)
(if (<= t 6.2e-16)
(* x (/ (/ (pow z y) a) (* y (exp b))))
(/ (* x (exp (* (+ t -1.0) (log a)))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -18000000000.0) {
tmp = (x * pow(a, (t + -1.0))) / y;
} else if (t <= 6.2e-16) {
tmp = x * ((pow(z, y) / a) / (y * exp(b)));
} else {
tmp = (x * exp(((t + -1.0) * log(a)))) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-18000000000.0d0)) then
tmp = (x * (a ** (t + (-1.0d0)))) / y
else if (t <= 6.2d-16) then
tmp = x * (((z ** y) / a) / (y * exp(b)))
else
tmp = (x * exp(((t + (-1.0d0)) * log(a)))) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -18000000000.0) {
tmp = (x * Math.pow(a, (t + -1.0))) / y;
} else if (t <= 6.2e-16) {
tmp = x * ((Math.pow(z, y) / a) / (y * Math.exp(b)));
} else {
tmp = (x * Math.exp(((t + -1.0) * Math.log(a)))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -18000000000.0: tmp = (x * math.pow(a, (t + -1.0))) / y elif t <= 6.2e-16: tmp = x * ((math.pow(z, y) / a) / (y * math.exp(b))) else: tmp = (x * math.exp(((t + -1.0) * math.log(a)))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -18000000000.0) tmp = Float64(Float64(x * (a ^ Float64(t + -1.0))) / y); elseif (t <= 6.2e-16) tmp = Float64(x * Float64(Float64((z ^ y) / a) / Float64(y * exp(b)))); else tmp = Float64(Float64(x * exp(Float64(Float64(t + -1.0) * log(a)))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -18000000000.0) tmp = (x * (a ^ (t + -1.0))) / y; elseif (t <= 6.2e-16) tmp = x * (((z ^ y) / a) / (y * exp(b))); else tmp = (x * exp(((t + -1.0) * log(a)))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -18000000000.0], N[(N[(x * N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 6.2e-16], N[(x * N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[Exp[N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -18000000000:\\
\;\;\;\;\frac{x \cdot {a}^{\left(t + -1\right)}}{y}\\
\mathbf{elif}\;t \leq 6.2 \cdot 10^{-16}:\\
\;\;\;\;x \cdot \frac{\frac{{z}^{y}}{a}}{y \cdot e^{b}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\left(t + -1\right) \cdot \log a}}{y}\\
\end{array}
\end{array}
if t < -1.8e10Initial program 100.0%
*-commutative100.0%
associate-/l*91.7%
associate--l+91.7%
fma-define91.7%
sub-neg91.7%
metadata-eval91.7%
Simplified91.7%
Taylor expanded in y around 0 91.8%
Taylor expanded in b around 0 87.7%
exp-to-pow87.7%
sub-neg87.7%
metadata-eval87.7%
+-commutative87.7%
Simplified87.7%
if -1.8e10 < t < 6.2000000000000002e-16Initial program 98.1%
associate-/l*96.9%
associate--l+96.9%
exp-sum88.2%
associate-/l*83.8%
*-commutative83.8%
exp-to-pow83.8%
exp-diff83.1%
*-commutative83.1%
exp-to-pow84.0%
sub-neg84.0%
metadata-eval84.0%
Simplified84.0%
Taylor expanded in t around 0 83.7%
associate-/r*88.7%
Simplified88.7%
if 6.2000000000000002e-16 < t Initial program 100.0%
*-commutative100.0%
associate-/l*85.7%
associate--l+85.7%
fma-define85.7%
sub-neg85.7%
metadata-eval85.7%
Simplified85.7%
Taylor expanded in y around 0 87.3%
Taylor expanded in b around 0 85.9%
Final simplification87.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (/ (pow z y) a) y))))
(if (<= y -5.9e+82)
t_1
(if (<= y 2e-287)
(/ (* x (pow a (+ t -1.0))) y)
(if (<= y 4e+95) (/ x (* y (* a (exp b)))) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * ((pow(z, y) / a) / y);
double tmp;
if (y <= -5.9e+82) {
tmp = t_1;
} else if (y <= 2e-287) {
tmp = (x * pow(a, (t + -1.0))) / y;
} else if (y <= 4e+95) {
tmp = x / (y * (a * exp(b)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x * (((z ** y) / a) / y)
if (y <= (-5.9d+82)) then
tmp = t_1
else if (y <= 2d-287) then
tmp = (x * (a ** (t + (-1.0d0)))) / y
else if (y <= 4d+95) then
tmp = x / (y * (a * exp(b)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * ((Math.pow(z, y) / a) / y);
double tmp;
if (y <= -5.9e+82) {
tmp = t_1;
} else if (y <= 2e-287) {
tmp = (x * Math.pow(a, (t + -1.0))) / y;
} else if (y <= 4e+95) {
tmp = x / (y * (a * Math.exp(b)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * ((math.pow(z, y) / a) / y) tmp = 0 if y <= -5.9e+82: tmp = t_1 elif y <= 2e-287: tmp = (x * math.pow(a, (t + -1.0))) / y elif y <= 4e+95: tmp = x / (y * (a * math.exp(b))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(Float64((z ^ y) / a) / y)) tmp = 0.0 if (y <= -5.9e+82) tmp = t_1; elseif (y <= 2e-287) tmp = Float64(Float64(x * (a ^ Float64(t + -1.0))) / y); elseif (y <= 4e+95) tmp = Float64(x / Float64(y * Float64(a * exp(b)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (((z ^ y) / a) / y); tmp = 0.0; if (y <= -5.9e+82) tmp = t_1; elseif (y <= 2e-287) tmp = (x * (a ^ (t + -1.0))) / y; elseif (y <= 4e+95) tmp = x / (y * (a * exp(b))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -5.9e+82], t$95$1, If[LessEqual[y, 2e-287], N[(N[(x * N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[y, 4e+95], N[(x / N[(y * N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{\frac{{z}^{y}}{a}}{y}\\
\mathbf{if}\;y \leq -5.9 \cdot 10^{+82}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2 \cdot 10^{-287}:\\
\;\;\;\;\frac{x \cdot {a}^{\left(t + -1\right)}}{y}\\
\mathbf{elif}\;y \leq 4 \cdot 10^{+95}:\\
\;\;\;\;\frac{x}{y \cdot \left(a \cdot e^{b}\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -5.8999999999999997e82 or 4.00000000000000008e95 < y Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum69.0%
associate-/l*62.1%
*-commutative62.1%
exp-to-pow62.1%
exp-diff56.3%
*-commutative56.3%
exp-to-pow56.3%
sub-neg56.3%
metadata-eval56.3%
Simplified56.3%
Taylor expanded in t around 0 56.4%
associate-/r*67.9%
Simplified67.9%
Taylor expanded in b around 0 90.9%
if -5.8999999999999997e82 < y < 2.00000000000000004e-287Initial program 98.0%
*-commutative98.0%
associate-/l*87.5%
associate--l+87.5%
fma-define87.5%
sub-neg87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in y around 0 91.7%
Taylor expanded in b around 0 74.2%
exp-to-pow75.0%
sub-neg75.0%
metadata-eval75.0%
+-commutative75.0%
Simplified75.0%
if 2.00000000000000004e-287 < y < 4.00000000000000008e95Initial program 99.1%
associate-/l*99.1%
associate--l+99.1%
exp-sum87.0%
associate-/l*87.0%
*-commutative87.0%
exp-to-pow87.0%
exp-diff78.9%
*-commutative78.9%
exp-to-pow79.7%
sub-neg79.7%
metadata-eval79.7%
Simplified79.7%
Taylor expanded in t around 0 73.3%
associate-/r*73.3%
Simplified73.3%
Taylor expanded in y around 0 81.9%
*-commutative81.9%
associate-*l*81.9%
*-commutative81.9%
Simplified81.9%
Final simplification82.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= (+ t -1.0) -1.000001)
(/ (/ (* x (pow a t)) a) y)
(if (<= (+ t -1.0) 1e+29)
(/ (* x (/ (pow z y) a)) y)
(/ (* x (pow a (+ t -1.0))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t + -1.0) <= -1.000001) {
tmp = ((x * pow(a, t)) / a) / y;
} else if ((t + -1.0) <= 1e+29) {
tmp = (x * (pow(z, y) / a)) / y;
} else {
tmp = (x * pow(a, (t + -1.0))) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((t + (-1.0d0)) <= (-1.000001d0)) then
tmp = ((x * (a ** t)) / a) / y
else if ((t + (-1.0d0)) <= 1d+29) then
tmp = (x * ((z ** y) / a)) / y
else
tmp = (x * (a ** (t + (-1.0d0)))) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t + -1.0) <= -1.000001) {
tmp = ((x * Math.pow(a, t)) / a) / y;
} else if ((t + -1.0) <= 1e+29) {
tmp = (x * (Math.pow(z, y) / a)) / y;
} else {
tmp = (x * Math.pow(a, (t + -1.0))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t + -1.0) <= -1.000001: tmp = ((x * math.pow(a, t)) / a) / y elif (t + -1.0) <= 1e+29: tmp = (x * (math.pow(z, y) / a)) / y else: tmp = (x * math.pow(a, (t + -1.0))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (Float64(t + -1.0) <= -1.000001) tmp = Float64(Float64(Float64(x * (a ^ t)) / a) / y); elseif (Float64(t + -1.0) <= 1e+29) tmp = Float64(Float64(x * Float64((z ^ y) / a)) / y); else tmp = Float64(Float64(x * (a ^ Float64(t + -1.0))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t + -1.0) <= -1.000001) tmp = ((x * (a ^ t)) / a) / y; elseif ((t + -1.0) <= 1e+29) tmp = (x * ((z ^ y) / a)) / y; else tmp = (x * (a ^ (t + -1.0))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[N[(t + -1.0), $MachinePrecision], -1.000001], N[(N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[N[(t + -1.0), $MachinePrecision], 1e+29], N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t + -1 \leq -1.000001:\\
\;\;\;\;\frac{\frac{x \cdot {a}^{t}}{a}}{y}\\
\mathbf{elif}\;t + -1 \leq 10^{+29}:\\
\;\;\;\;\frac{x \cdot \frac{{z}^{y}}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot {a}^{\left(t + -1\right)}}{y}\\
\end{array}
\end{array}
if (-.f64 t #s(literal 1 binary64)) < -1.00000099999999992Initial program 99.9%
*-commutative99.9%
associate-/l*92.2%
associate--l+92.2%
fma-define92.2%
sub-neg92.2%
metadata-eval92.2%
Simplified92.2%
Taylor expanded in y around 0 92.3%
div-exp73.0%
associate-/l*71.1%
exp-to-pow71.1%
sub-neg71.1%
metadata-eval71.1%
Simplified71.1%
unpow-prod-up71.2%
unpow-171.2%
Applied egg-rr71.2%
associate-*r/71.2%
*-rgt-identity71.2%
Simplified71.2%
Taylor expanded in b around 0 83.0%
if -1.00000099999999992 < (-.f64 t #s(literal 1 binary64)) < 9.99999999999999914e28Initial program 98.3%
associate-/l*97.1%
associate--l+97.1%
exp-sum86.7%
associate-/l*82.6%
*-commutative82.6%
exp-to-pow82.6%
exp-diff81.2%
*-commutative81.2%
exp-to-pow82.1%
sub-neg82.1%
metadata-eval82.1%
Simplified82.1%
Taylor expanded in t around 0 82.1%
associate-/r*87.0%
Simplified87.0%
Taylor expanded in b around 0 73.9%
associate-*r/75.8%
Applied egg-rr75.8%
if 9.99999999999999914e28 < (-.f64 t #s(literal 1 binary64)) Initial program 100.0%
*-commutative100.0%
associate-/l*89.8%
associate--l+89.8%
fma-define89.8%
sub-neg89.8%
metadata-eval89.8%
Simplified89.8%
Taylor expanded in y around 0 91.7%
Taylor expanded in b around 0 91.7%
exp-to-pow91.7%
sub-neg91.7%
metadata-eval91.7%
+-commutative91.7%
Simplified91.7%
Final simplification80.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -2.65e-11) (not (<= y 6.4e+94))) (* x (/ (/ (pow z y) a) y)) (/ x (* y (* a (exp b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -2.65e-11) || !(y <= 6.4e+94)) {
tmp = x * ((pow(z, y) / a) / y);
} else {
tmp = x / (y * (a * exp(b)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-2.65d-11)) .or. (.not. (y <= 6.4d+94))) then
tmp = x * (((z ** y) / a) / y)
else
tmp = x / (y * (a * exp(b)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -2.65e-11) || !(y <= 6.4e+94)) {
tmp = x * ((Math.pow(z, y) / a) / y);
} else {
tmp = x / (y * (a * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -2.65e-11) or not (y <= 6.4e+94): tmp = x * ((math.pow(z, y) / a) / y) else: tmp = x / (y * (a * math.exp(b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -2.65e-11) || !(y <= 6.4e+94)) tmp = Float64(x * Float64(Float64((z ^ y) / a) / y)); else tmp = Float64(x / Float64(y * Float64(a * exp(b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -2.65e-11) || ~((y <= 6.4e+94))) tmp = x * (((z ^ y) / a) / y); else tmp = x / (y * (a * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -2.65e-11], N[Not[LessEqual[y, 6.4e+94]], $MachinePrecision]], N[(x * N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.65 \cdot 10^{-11} \lor \neg \left(y \leq 6.4 \cdot 10^{+94}\right):\\
\;\;\;\;x \cdot \frac{\frac{{z}^{y}}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(a \cdot e^{b}\right)}\\
\end{array}
\end{array}
if y < -2.6499999999999999e-11 or 6.40000000000000028e94 < y Initial program 99.8%
associate-/l*99.8%
associate--l+99.8%
exp-sum65.8%
associate-/l*60.3%
*-commutative60.3%
exp-to-pow60.3%
exp-diff54.8%
*-commutative54.8%
exp-to-pow55.0%
sub-neg55.0%
metadata-eval55.0%
Simplified55.0%
Taylor expanded in t around 0 53.4%
associate-/r*63.5%
Simplified63.5%
Taylor expanded in b around 0 82.0%
if -2.6499999999999999e-11 < y < 6.40000000000000028e94Initial program 98.4%
associate-/l*97.2%
associate--l+97.2%
exp-sum91.1%
associate-/l*91.1%
*-commutative91.1%
exp-to-pow91.1%
exp-diff83.6%
*-commutative83.6%
exp-to-pow84.4%
sub-neg84.4%
metadata-eval84.4%
Simplified84.4%
Taylor expanded in t around 0 69.0%
associate-/r*69.1%
Simplified69.1%
Taylor expanded in y around 0 73.4%
*-commutative73.4%
associate-*l*73.4%
*-commutative73.4%
Simplified73.4%
Final simplification77.0%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -6e+144)
(*
x
(+
(/ 1.0 y)
(/ (* b (+ -1.0 (* b (+ 0.5 (* b -0.16666666666666666))))) y)))
(if (<= b 305.0) (* (/ 1.0 a) (/ x y)) (/ x (* y (exp b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -6e+144) {
tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y));
} else if (b <= 305.0) {
tmp = (1.0 / a) * (x / y);
} else {
tmp = x / (y * exp(b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-6d+144)) then
tmp = x * ((1.0d0 / y) + ((b * ((-1.0d0) + (b * (0.5d0 + (b * (-0.16666666666666666d0)))))) / y))
else if (b <= 305.0d0) then
tmp = (1.0d0 / a) * (x / y)
else
tmp = x / (y * exp(b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -6e+144) {
tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y));
} else if (b <= 305.0) {
tmp = (1.0 / a) * (x / y);
} else {
tmp = x / (y * Math.exp(b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -6e+144: tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y)) elif b <= 305.0: tmp = (1.0 / a) * (x / y) else: tmp = x / (y * math.exp(b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -6e+144) tmp = Float64(x * Float64(Float64(1.0 / y) + Float64(Float64(b * Float64(-1.0 + Float64(b * Float64(0.5 + Float64(b * -0.16666666666666666))))) / y))); elseif (b <= 305.0) tmp = Float64(Float64(1.0 / a) * Float64(x / y)); else tmp = Float64(x / Float64(y * exp(b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -6e+144) tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y)); elseif (b <= 305.0) tmp = (1.0 / a) * (x / y); else tmp = x / (y * exp(b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -6e+144], N[(x * N[(N[(1.0 / y), $MachinePrecision] + N[(N[(b * N[(-1.0 + N[(b * N[(0.5 + N[(b * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 305.0], N[(N[(1.0 / a), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6 \cdot 10^{+144}:\\
\;\;\;\;x \cdot \left(\frac{1}{y} + \frac{b \cdot \left(-1 + b \cdot \left(0.5 + b \cdot -0.16666666666666666\right)\right)}{y}\right)\\
\mathbf{elif}\;b \leq 305:\\
\;\;\;\;\frac{1}{a} \cdot \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot e^{b}}\\
\end{array}
\end{array}
if b < -5.9999999999999998e144Initial program 100.0%
*-commutative100.0%
associate-/l*97.1%
associate--l+97.1%
fma-define97.1%
sub-neg97.1%
metadata-eval97.1%
Simplified97.1%
Taylor expanded in b around inf 85.5%
neg-mul-185.5%
Simplified85.5%
Taylor expanded in b around 0 83.0%
Taylor expanded in y around 0 85.8%
Taylor expanded in x around 0 88.4%
if -5.9999999999999998e144 < b < 305Initial program 98.4%
associate-/l*97.4%
associate--l+97.4%
exp-sum82.0%
associate-/l*78.3%
*-commutative78.3%
exp-to-pow78.3%
exp-diff75.9%
*-commutative75.9%
exp-to-pow76.7%
sub-neg76.7%
metadata-eval76.7%
Simplified76.7%
Taylor expanded in t around 0 58.6%
associate-/r*65.4%
Simplified65.4%
Taylor expanded in b around 0 70.9%
Taylor expanded in y around 0 45.0%
*-un-lft-identity45.0%
times-frac46.6%
Applied egg-rr46.6%
if 305 < b Initial program 100.0%
*-commutative100.0%
associate-/l*89.8%
associate--l+89.8%
fma-define89.8%
sub-neg89.8%
metadata-eval89.8%
Simplified89.8%
Taylor expanded in b around inf 71.5%
neg-mul-171.5%
Simplified71.5%
exp-neg71.5%
frac-times80.0%
*-un-lft-identity80.0%
*-commutative80.0%
Applied egg-rr80.0%
Final simplification59.8%
(FPCore (x y z t a b) :precision binary64 (if (<= y -1.5e+138) (/ (* x (exp b)) y) (/ x (* y (* a (exp b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -1.5e+138) {
tmp = (x * exp(b)) / y;
} else {
tmp = x / (y * (a * exp(b)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (y <= (-1.5d+138)) then
tmp = (x * exp(b)) / y
else
tmp = x / (y * (a * exp(b)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -1.5e+138) {
tmp = (x * Math.exp(b)) / y;
} else {
tmp = x / (y * (a * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -1.5e+138: tmp = (x * math.exp(b)) / y else: tmp = x / (y * (a * math.exp(b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -1.5e+138) tmp = Float64(Float64(x * exp(b)) / y); else tmp = Float64(x / Float64(y * Float64(a * exp(b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -1.5e+138) tmp = (x * exp(b)) / y; else tmp = x / (y * (a * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -1.5e+138], N[(N[(x * N[Exp[b], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(y * N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.5 \cdot 10^{+138}:\\
\;\;\;\;\frac{x \cdot e^{b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(a \cdot e^{b}\right)}\\
\end{array}
\end{array}
if y < -1.50000000000000005e138Initial program 100.0%
*-commutative100.0%
associate-/l*83.3%
associate--l+83.3%
fma-define83.3%
sub-neg83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in b around inf 42.6%
neg-mul-142.6%
Simplified42.6%
associate-*r/45.6%
add-sqr-sqrt20.2%
sqrt-unprod34.7%
sqr-neg34.7%
sqrt-unprod14.4%
add-sqr-sqrt56.5%
Applied egg-rr56.5%
if -1.50000000000000005e138 < y Initial program 98.8%
associate-/l*98.0%
associate--l+98.0%
exp-sum84.4%
associate-/l*83.5%
*-commutative83.5%
exp-to-pow83.5%
exp-diff76.2%
*-commutative76.2%
exp-to-pow76.8%
sub-neg76.8%
metadata-eval76.8%
Simplified76.8%
Taylor expanded in t around 0 64.8%
associate-/r*67.6%
Simplified67.6%
Taylor expanded in y around 0 61.3%
*-commutative61.3%
associate-*l*61.3%
*-commutative61.3%
Simplified61.3%
Final simplification60.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.75e+145)
(*
x
(+
(/ 1.0 y)
(/ (* b (+ -1.0 (* b (+ 0.5 (* b -0.16666666666666666))))) y)))
(/ (/ x a) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.75e+145) {
tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y));
} else {
tmp = (x / a) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.75d+145)) then
tmp = x * ((1.0d0 / y) + ((b * ((-1.0d0) + (b * (0.5d0 + (b * (-0.16666666666666666d0)))))) / y))
else
tmp = (x / a) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.75e+145) {
tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y));
} else {
tmp = (x / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.75e+145: tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y)) else: tmp = (x / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.75e+145) tmp = Float64(x * Float64(Float64(1.0 / y) + Float64(Float64(b * Float64(-1.0 + Float64(b * Float64(0.5 + Float64(b * -0.16666666666666666))))) / y))); else tmp = Float64(Float64(x / a) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.75e+145) tmp = x * ((1.0 / y) + ((b * (-1.0 + (b * (0.5 + (b * -0.16666666666666666))))) / y)); else tmp = (x / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.75e+145], N[(x * N[(N[(1.0 / y), $MachinePrecision] + N[(N[(b * N[(-1.0 + N[(b * N[(0.5 + N[(b * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.75 \cdot 10^{+145}:\\
\;\;\;\;x \cdot \left(\frac{1}{y} + \frac{b \cdot \left(-1 + b \cdot \left(0.5 + b \cdot -0.16666666666666666\right)\right)}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\end{array}
\end{array}
if b < -1.7500000000000001e145Initial program 100.0%
*-commutative100.0%
associate-/l*97.0%
associate--l+97.0%
fma-define97.0%
sub-neg97.0%
metadata-eval97.0%
Simplified97.0%
Taylor expanded in b around inf 85.0%
neg-mul-185.0%
Simplified85.0%
Taylor expanded in b around 0 82.4%
Taylor expanded in y around 0 85.3%
Taylor expanded in x around 0 88.1%
if -1.7500000000000001e145 < b Initial program 98.8%
*-commutative98.8%
associate-/l*88.2%
associate--l+88.2%
fma-define88.2%
sub-neg88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in y around 0 78.0%
div-exp69.0%
associate-/l*67.6%
exp-to-pow68.2%
sub-neg68.2%
metadata-eval68.2%
Simplified68.2%
unpow-prod-up68.2%
unpow-168.2%
Applied egg-rr68.2%
associate-*r/68.2%
*-rgt-identity68.2%
Simplified68.2%
Taylor expanded in b around 0 66.9%
Taylor expanded in t around 0 38.4%
Final simplification44.8%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.85e+148) (+ (/ x y) (* b (- (* 0.5 (* x (/ b y))) (/ x y)))) (/ (/ x a) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.85e+148) {
tmp = (x / y) + (b * ((0.5 * (x * (b / y))) - (x / y)));
} else {
tmp = (x / a) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.85d+148)) then
tmp = (x / y) + (b * ((0.5d0 * (x * (b / y))) - (x / y)))
else
tmp = (x / a) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.85e+148) {
tmp = (x / y) + (b * ((0.5 * (x * (b / y))) - (x / y)));
} else {
tmp = (x / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.85e+148: tmp = (x / y) + (b * ((0.5 * (x * (b / y))) - (x / y))) else: tmp = (x / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.85e+148) tmp = Float64(Float64(x / y) + Float64(b * Float64(Float64(0.5 * Float64(x * Float64(b / y))) - Float64(x / y)))); else tmp = Float64(Float64(x / a) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.85e+148) tmp = (x / y) + (b * ((0.5 * (x * (b / y))) - (x / y))); else tmp = (x / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.85e+148], N[(N[(x / y), $MachinePrecision] + N[(b * N[(N[(0.5 * N[(x * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.85 \cdot 10^{+148}:\\
\;\;\;\;\frac{x}{y} + b \cdot \left(0.5 \cdot \left(x \cdot \frac{b}{y}\right) - \frac{x}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\end{array}
\end{array}
if b < -1.8500000000000001e148Initial program 100.0%
*-commutative100.0%
associate-/l*97.0%
associate--l+97.0%
fma-define97.0%
sub-neg97.0%
metadata-eval97.0%
Simplified97.0%
Taylor expanded in b around inf 85.0%
neg-mul-185.0%
Simplified85.0%
Taylor expanded in b around 0 82.4%
Taylor expanded in b around 0 73.9%
mul-1-neg73.9%
+-commutative73.9%
unsub-neg73.9%
*-commutative73.9%
associate-*r/73.9%
Simplified73.9%
if -1.8500000000000001e148 < b Initial program 98.8%
*-commutative98.8%
associate-/l*88.2%
associate--l+88.2%
fma-define88.2%
sub-neg88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in y around 0 78.0%
div-exp69.0%
associate-/l*67.6%
exp-to-pow68.2%
sub-neg68.2%
metadata-eval68.2%
Simplified68.2%
unpow-prod-up68.2%
unpow-168.2%
Applied egg-rr68.2%
associate-*r/68.2%
*-rgt-identity68.2%
Simplified68.2%
Taylor expanded in b around 0 66.9%
Taylor expanded in t around 0 38.4%
Final simplification42.9%
(FPCore (x y z t a b) :precision binary64 (if (<= b -2.05e+145) (+ (/ x y) (/ (* b (- (* x (* b 0.5)) x)) y)) (/ (/ x a) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.05e+145) {
tmp = (x / y) + ((b * ((x * (b * 0.5)) - x)) / y);
} else {
tmp = (x / a) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-2.05d+145)) then
tmp = (x / y) + ((b * ((x * (b * 0.5d0)) - x)) / y)
else
tmp = (x / a) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.05e+145) {
tmp = (x / y) + ((b * ((x * (b * 0.5)) - x)) / y);
} else {
tmp = (x / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.05e+145: tmp = (x / y) + ((b * ((x * (b * 0.5)) - x)) / y) else: tmp = (x / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.05e+145) tmp = Float64(Float64(x / y) + Float64(Float64(b * Float64(Float64(x * Float64(b * 0.5)) - x)) / y)); else tmp = Float64(Float64(x / a) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.05e+145) tmp = (x / y) + ((b * ((x * (b * 0.5)) - x)) / y); else tmp = (x / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.05e+145], N[(N[(x / y), $MachinePrecision] + N[(N[(b * N[(N[(x * N[(b * 0.5), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.05 \cdot 10^{+145}:\\
\;\;\;\;\frac{x}{y} + \frac{b \cdot \left(x \cdot \left(b \cdot 0.5\right) - x\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\end{array}
\end{array}
if b < -2.0500000000000001e145Initial program 100.0%
*-commutative100.0%
associate-/l*97.0%
associate--l+97.0%
fma-define97.0%
sub-neg97.0%
metadata-eval97.0%
Simplified97.0%
Taylor expanded in b around inf 85.0%
neg-mul-185.0%
Simplified85.0%
Taylor expanded in b around 0 82.4%
Taylor expanded in y around 0 85.3%
Taylor expanded in b around 0 76.5%
*-commutative76.5%
*-commutative76.5%
associate-*l*76.5%
Simplified76.5%
if -2.0500000000000001e145 < b Initial program 98.8%
*-commutative98.8%
associate-/l*88.2%
associate--l+88.2%
fma-define88.2%
sub-neg88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in y around 0 78.0%
div-exp69.0%
associate-/l*67.6%
exp-to-pow68.2%
sub-neg68.2%
metadata-eval68.2%
Simplified68.2%
unpow-prod-up68.2%
unpow-168.2%
Applied egg-rr68.2%
associate-*r/68.2%
*-rgt-identity68.2%
Simplified68.2%
Taylor expanded in b around 0 66.9%
Taylor expanded in t around 0 38.4%
Final simplification43.3%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.2e+146) (/ (+ (* x y) (* y (* x b))) (* y (- y))) (/ (/ x a) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.2e+146) {
tmp = ((x * y) + (y * (x * b))) / (y * -y);
} else {
tmp = (x / a) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.2d+146)) then
tmp = ((x * y) + (y * (x * b))) / (y * -y)
else
tmp = (x / a) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.2e+146) {
tmp = ((x * y) + (y * (x * b))) / (y * -y);
} else {
tmp = (x / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.2e+146: tmp = ((x * y) + (y * (x * b))) / (y * -y) else: tmp = (x / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.2e+146) tmp = Float64(Float64(Float64(x * y) + Float64(y * Float64(x * b))) / Float64(y * Float64(-y))); else tmp = Float64(Float64(x / a) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.2e+146) tmp = ((x * y) + (y * (x * b))) / (y * -y); else tmp = (x / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.2e+146], N[(N[(N[(x * y), $MachinePrecision] + N[(y * N[(x * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * (-y)), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.2 \cdot 10^{+146}:\\
\;\;\;\;\frac{x \cdot y + y \cdot \left(x \cdot b\right)}{y \cdot \left(-y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\end{array}
\end{array}
if b < -1.2000000000000001e146Initial program 100.0%
*-commutative100.0%
associate-/l*97.0%
associate--l+97.0%
fma-define97.0%
sub-neg97.0%
metadata-eval97.0%
Simplified97.0%
Taylor expanded in b around inf 85.0%
neg-mul-185.0%
Simplified85.0%
*-commutative85.0%
exp-neg85.0%
un-div-inv85.0%
Applied egg-rr85.0%
Taylor expanded in b around 0 48.2%
+-commutative48.2%
associate-*r/42.5%
neg-mul-142.5%
unsub-neg42.5%
*-commutative42.5%
associate-*l/48.2%
associate-*r/53.4%
Simplified53.4%
frac-2neg53.4%
mul-1-neg53.4%
associate-*r/48.2%
*-commutative48.2%
frac-sub61.6%
add-sqr-sqrt24.8%
sqrt-unprod55.5%
mul-1-neg55.5%
mul-1-neg55.5%
sqr-neg55.5%
sqrt-unprod36.8%
add-sqr-sqrt61.6%
*-commutative61.6%
Applied egg-rr61.6%
if -1.2000000000000001e146 < b Initial program 98.8%
*-commutative98.8%
associate-/l*88.2%
associate--l+88.2%
fma-define88.2%
sub-neg88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in y around 0 78.0%
div-exp69.0%
associate-/l*67.6%
exp-to-pow68.2%
sub-neg68.2%
metadata-eval68.2%
Simplified68.2%
unpow-prod-up68.2%
unpow-168.2%
Applied egg-rr68.2%
associate-*r/68.2%
*-rgt-identity68.2%
Simplified68.2%
Taylor expanded in b around 0 66.9%
Taylor expanded in t around 0 38.4%
Final simplification41.4%
(FPCore (x y z t a b) :precision binary64 (if (<= b -2.3e+146) (* x (/ b (- y))) (/ (/ x a) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.3e+146) {
tmp = x * (b / -y);
} else {
tmp = (x / a) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-2.3d+146)) then
tmp = x * (b / -y)
else
tmp = (x / a) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.3e+146) {
tmp = x * (b / -y);
} else {
tmp = (x / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.3e+146: tmp = x * (b / -y) else: tmp = (x / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.3e+146) tmp = Float64(x * Float64(b / Float64(-y))); else tmp = Float64(Float64(x / a) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.3e+146) tmp = x * (b / -y); else tmp = (x / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.3e+146], N[(x * N[(b / (-y)), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.3 \cdot 10^{+146}:\\
\;\;\;\;x \cdot \frac{b}{-y}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\end{array}
\end{array}
if b < -2.3e146Initial program 100.0%
*-commutative100.0%
associate-/l*97.0%
associate--l+97.0%
fma-define97.0%
sub-neg97.0%
metadata-eval97.0%
Simplified97.0%
Taylor expanded in b around inf 85.0%
neg-mul-185.0%
Simplified85.0%
*-commutative85.0%
exp-neg85.0%
un-div-inv85.0%
Applied egg-rr85.0%
Taylor expanded in b around 0 48.2%
+-commutative48.2%
associate-*r/42.5%
neg-mul-142.5%
unsub-neg42.5%
*-commutative42.5%
associate-*l/48.2%
associate-*r/53.4%
Simplified53.4%
Taylor expanded in b around inf 48.2%
mul-1-neg48.2%
*-commutative48.2%
distribute-neg-frac248.2%
associate-*r/53.4%
Simplified53.4%
if -2.3e146 < b Initial program 98.8%
*-commutative98.8%
associate-/l*88.2%
associate--l+88.2%
fma-define88.2%
sub-neg88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in y around 0 78.0%
div-exp69.0%
associate-/l*67.6%
exp-to-pow68.2%
sub-neg68.2%
metadata-eval68.2%
Simplified68.2%
unpow-prod-up68.2%
unpow-168.2%
Applied egg-rr68.2%
associate-*r/68.2%
*-rgt-identity68.2%
Simplified68.2%
Taylor expanded in b around 0 66.9%
Taylor expanded in t around 0 38.4%
(FPCore (x y z t a b) :precision binary64 (/ (/ x a) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x / a) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x / a) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x / a) / y;
}
def code(x, y, z, t, a, b): return (x / a) / y
function code(x, y, z, t, a, b) return Float64(Float64(x / a) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x / a) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{x}{a}}{y}
\end{array}
Initial program 99.0%
*-commutative99.0%
associate-/l*89.4%
associate--l+89.4%
fma-define89.4%
sub-neg89.4%
metadata-eval89.4%
Simplified89.4%
Taylor expanded in y around 0 80.1%
div-exp71.5%
associate-/l*68.3%
exp-to-pow68.8%
sub-neg68.8%
metadata-eval68.8%
Simplified68.8%
unpow-prod-up68.8%
unpow-168.8%
Applied egg-rr68.8%
associate-*r/68.8%
*-rgt-identity68.8%
Simplified68.8%
Taylor expanded in b around 0 64.7%
Taylor expanded in t around 0 36.5%
(FPCore (x y z t a b) :precision binary64 (/ x (* y a)))
double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / (y * a)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
def code(x, y, z, t, a, b): return x / (y * a)
function code(x, y, z, t, a, b) return Float64(x / Float64(y * a)) end
function tmp = code(x, y, z, t, a, b) tmp = x / (y * a); end
code[x_, y_, z_, t_, a_, b_] := N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y \cdot a}
\end{array}
Initial program 99.0%
associate-/l*98.3%
associate--l+98.3%
exp-sum80.3%
associate-/l*78.0%
*-commutative78.0%
exp-to-pow78.0%
exp-diff71.3%
*-commutative71.3%
exp-to-pow71.9%
sub-neg71.9%
metadata-eval71.9%
Simplified71.9%
Taylor expanded in t around 0 62.4%
associate-/r*66.7%
Simplified66.7%
Taylor expanded in b around 0 58.7%
Taylor expanded in y around 0 34.8%
Final simplification34.8%
(FPCore (x y z t a b) :precision binary64 (/ x y))
double code(double x, double y, double z, double t, double a, double b) {
return x / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / y;
}
def code(x, y, z, t, a, b): return x / y
function code(x, y, z, t, a, b) return Float64(x / y) end
function tmp = code(x, y, z, t, a, b) tmp = x / y; end
code[x_, y_, z_, t_, a_, b_] := N[(x / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y}
\end{array}
Initial program 99.0%
*-commutative99.0%
associate-/l*89.4%
associate--l+89.4%
fma-define89.4%
sub-neg89.4%
metadata-eval89.4%
Simplified89.4%
Taylor expanded in b around inf 45.6%
neg-mul-145.6%
Simplified45.6%
Taylor expanded in b around 0 22.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (pow a (- t 1.0)))
(t_2 (/ (* x (/ t_1 y)) (- (+ b 1.0) (* y (log z))))))
(if (< t -0.8845848504127471)
t_2
(if (< t 852031.2288374073)
(/ (* (/ x y) t_1) (exp (- b (* (log z) y))))
t_2))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = pow(a, (t - 1.0));
double t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * log(z)));
double tmp;
if (t < -0.8845848504127471) {
tmp = t_2;
} else if (t < 852031.2288374073) {
tmp = ((x / y) * t_1) / exp((b - (log(z) * y)));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a ** (t - 1.0d0)
t_2 = (x * (t_1 / y)) / ((b + 1.0d0) - (y * log(z)))
if (t < (-0.8845848504127471d0)) then
tmp = t_2
else if (t < 852031.2288374073d0) then
tmp = ((x / y) * t_1) / exp((b - (log(z) * y)))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = Math.pow(a, (t - 1.0));
double t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * Math.log(z)));
double tmp;
if (t < -0.8845848504127471) {
tmp = t_2;
} else if (t < 852031.2288374073) {
tmp = ((x / y) * t_1) / Math.exp((b - (Math.log(z) * y)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = math.pow(a, (t - 1.0)) t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * math.log(z))) tmp = 0 if t < -0.8845848504127471: tmp = t_2 elif t < 852031.2288374073: tmp = ((x / y) * t_1) / math.exp((b - (math.log(z) * y))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = a ^ Float64(t - 1.0) t_2 = Float64(Float64(x * Float64(t_1 / y)) / Float64(Float64(b + 1.0) - Float64(y * log(z)))) tmp = 0.0 if (t < -0.8845848504127471) tmp = t_2; elseif (t < 852031.2288374073) tmp = Float64(Float64(Float64(x / y) * t_1) / exp(Float64(b - Float64(log(z) * y)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a ^ (t - 1.0); t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * log(z))); tmp = 0.0; if (t < -0.8845848504127471) tmp = t_2; elseif (t < 852031.2288374073) tmp = ((x / y) * t_1) / exp((b - (log(z) * y))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[Power[a, N[(t - 1.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision] / N[(N[(b + 1.0), $MachinePrecision] - N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -0.8845848504127471], t$95$2, If[Less[t, 852031.2288374073], N[(N[(N[(x / y), $MachinePrecision] * t$95$1), $MachinePrecision] / N[Exp[N[(b - N[(N[Log[z], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {a}^{\left(t - 1\right)}\\
t_2 := \frac{x \cdot \frac{t\_1}{y}}{\left(b + 1\right) - y \cdot \log z}\\
\mathbf{if}\;t < -0.8845848504127471:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 852031.2288374073:\\
\;\;\;\;\frac{\frac{x}{y} \cdot t\_1}{e^{b - \log z \cdot y}}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024108
(FPCore (x y z t a b)
:name "Numeric.SpecFunctions:incompleteBetaWorker from math-functions-0.1.5.2, A"
:precision binary64
:alt
(if (< t -0.8845848504127471) (/ (* x (/ (pow a (- t 1.0)) y)) (- (+ b 1.0) (* y (log z)))) (if (< t 852031.2288374073) (/ (* (/ x y) (pow a (- t 1.0))) (exp (- b (* (log z) y)))) (/ (* x (/ (pow a (- t 1.0)) y)) (- (+ b 1.0) (* y (log z))))))
(/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))