
(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 20 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)) (* (log a) (+ t -1.0))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + (log(a) * (t + -1.0))) - 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)) + (log(a) * (t + (-1.0d0)))) - 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)) + (Math.log(a) * (t + -1.0))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + (math.log(a) * (t + -1.0))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(log(a) * Float64(t + -1.0))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + (log(a) * (t + -1.0))) - 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[Log[a], $MachinePrecision] * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \log a \cdot \left(t + -1\right)\right) - b}}{y}
\end{array}
Initial program 98.9%
Final simplification98.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -0.0024) (not (<= y 1.35e-28))) (/ (* x (exp (- (- (* y (log z)) (log a)) b))) y) (/ (* x (exp (- (* (log a) (+ t -1.0)) b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -0.0024) || !(y <= 1.35e-28)) {
tmp = (x * exp((((y * log(z)) - log(a)) - b))) / y;
} else {
tmp = (x * exp(((log(a) * (t + -1.0)) - 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 <= (-0.0024d0)) .or. (.not. (y <= 1.35d-28))) then
tmp = (x * exp((((y * log(z)) - log(a)) - b))) / y
else
tmp = (x * exp(((log(a) * (t + (-1.0d0))) - 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 <= -0.0024) || !(y <= 1.35e-28)) {
tmp = (x * Math.exp((((y * Math.log(z)) - Math.log(a)) - b))) / y;
} else {
tmp = (x * Math.exp(((Math.log(a) * (t + -1.0)) - b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -0.0024) or not (y <= 1.35e-28): tmp = (x * math.exp((((y * math.log(z)) - math.log(a)) - b))) / y else: tmp = (x * math.exp(((math.log(a) * (t + -1.0)) - b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -0.0024) || !(y <= 1.35e-28)) tmp = Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) - log(a)) - b))) / y); else tmp = Float64(Float64(x * exp(Float64(Float64(log(a) * Float64(t + -1.0)) - b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -0.0024) || ~((y <= 1.35e-28))) tmp = (x * exp((((y * log(z)) - log(a)) - b))) / y; else tmp = (x * exp(((log(a) * (t + -1.0)) - b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -0.0024], N[Not[LessEqual[y, 1.35e-28]], $MachinePrecision]], N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] - N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * N[Exp[N[(N[(N[Log[a], $MachinePrecision] * N[(t + -1.0), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -0.0024 \lor \neg \left(y \leq 1.35 \cdot 10^{-28}\right):\\
\;\;\;\;\frac{x \cdot e^{\left(y \cdot \log z - \log a\right) - b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\log a \cdot \left(t + -1\right) - b}}{y}\\
\end{array}
\end{array}
if y < -0.00239999999999999979 or 1.3499999999999999e-28 < y Initial program 99.9%
Taylor expanded in t around 0 92.6%
+-commutative92.6%
mul-1-neg92.6%
unsub-neg92.6%
Simplified92.6%
if -0.00239999999999999979 < y < 1.3499999999999999e-28Initial program 97.9%
associate-/l*97.5%
fma-def97.5%
sub-neg97.5%
metadata-eval97.5%
Simplified97.5%
Taylor expanded in y around 0 97.9%
Final simplification95.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* x (exp (- (* (log a) (+ t -1.0)) b))) y))
(t_2 (/ x (* y (/ a (pow z y))))))
(if (<= y -2.65e+91)
t_2
(if (<= y -4.5e+44)
t_1
(if (<= y -4.6e-40)
(* (/ x (* y (exp b))) (/ (pow z y) a))
(if (<= y 9.5e+84) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * exp(((log(a) * (t + -1.0)) - b))) / y;
double t_2 = x / (y * (a / pow(z, y)));
double tmp;
if (y <= -2.65e+91) {
tmp = t_2;
} else if (y <= -4.5e+44) {
tmp = t_1;
} else if (y <= -4.6e-40) {
tmp = (x / (y * exp(b))) * (pow(z, y) / a);
} else if (y <= 9.5e+84) {
tmp = t_1;
} 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 = (x * exp(((log(a) * (t + (-1.0d0))) - b))) / y
t_2 = x / (y * (a / (z ** y)))
if (y <= (-2.65d+91)) then
tmp = t_2
else if (y <= (-4.5d+44)) then
tmp = t_1
else if (y <= (-4.6d-40)) then
tmp = (x / (y * exp(b))) * ((z ** y) / a)
else if (y <= 9.5d+84) then
tmp = t_1
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 = (x * Math.exp(((Math.log(a) * (t + -1.0)) - b))) / y;
double t_2 = x / (y * (a / Math.pow(z, y)));
double tmp;
if (y <= -2.65e+91) {
tmp = t_2;
} else if (y <= -4.5e+44) {
tmp = t_1;
} else if (y <= -4.6e-40) {
tmp = (x / (y * Math.exp(b))) * (Math.pow(z, y) / a);
} else if (y <= 9.5e+84) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x * math.exp(((math.log(a) * (t + -1.0)) - b))) / y t_2 = x / (y * (a / math.pow(z, y))) tmp = 0 if y <= -2.65e+91: tmp = t_2 elif y <= -4.5e+44: tmp = t_1 elif y <= -4.6e-40: tmp = (x / (y * math.exp(b))) * (math.pow(z, y) / a) elif y <= 9.5e+84: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * exp(Float64(Float64(log(a) * Float64(t + -1.0)) - b))) / y) t_2 = Float64(x / Float64(y * Float64(a / (z ^ y)))) tmp = 0.0 if (y <= -2.65e+91) tmp = t_2; elseif (y <= -4.5e+44) tmp = t_1; elseif (y <= -4.6e-40) tmp = Float64(Float64(x / Float64(y * exp(b))) * Float64((z ^ y) / a)); elseif (y <= 9.5e+84) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x * exp(((log(a) * (t + -1.0)) - b))) / y; t_2 = x / (y * (a / (z ^ y))); tmp = 0.0; if (y <= -2.65e+91) tmp = t_2; elseif (y <= -4.5e+44) tmp = t_1; elseif (y <= -4.6e-40) tmp = (x / (y * exp(b))) * ((z ^ y) / a); elseif (y <= 9.5e+84) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[Exp[N[(N[(N[Log[a], $MachinePrecision] * N[(t + -1.0), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(y * N[(a / N[Power[z, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.65e+91], t$95$2, If[LessEqual[y, -4.5e+44], t$95$1, If[LessEqual[y, -4.6e-40], N[(N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.5e+84], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot e^{\log a \cdot \left(t + -1\right) - b}}{y}\\
t_2 := \frac{x}{y \cdot \frac{a}{{z}^{y}}}\\
\mathbf{if}\;y \leq -2.65 \cdot 10^{+91}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -4.5 \cdot 10^{+44}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -4.6 \cdot 10^{-40}:\\
\;\;\;\;\frac{x}{y \cdot e^{b}} \cdot \frac{{z}^{y}}{a}\\
\mathbf{elif}\;y \leq 9.5 \cdot 10^{+84}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -2.64999999999999998e91 or 9.49999999999999979e84 < y Initial program 100.0%
associate-*l/87.6%
associate--l+87.6%
exp-sum57.7%
associate-*r*57.7%
*-commutative57.7%
exp-to-pow57.7%
exp-diff56.7%
*-commutative56.7%
exp-to-pow56.7%
sub-neg56.7%
metadata-eval56.7%
Simplified56.7%
Taylor expanded in t around 0 66.0%
*-commutative66.0%
times-frac71.2%
Simplified71.2%
Taylor expanded in b around 0 80.5%
*-commutative80.5%
clear-num80.5%
frac-times90.9%
*-un-lft-identity90.9%
Applied egg-rr90.9%
if -2.64999999999999998e91 < y < -4.5e44 or -4.6e-40 < y < 9.49999999999999979e84Initial program 98.4%
associate-/l*98.0%
fma-def98.0%
sub-neg98.0%
metadata-eval98.0%
Simplified98.0%
Taylor expanded in y around 0 95.6%
if -4.5e44 < y < -4.6e-40Initial program 97.8%
associate-*l/97.8%
associate--l+97.8%
exp-sum92.1%
associate-*r*92.1%
*-commutative92.1%
exp-to-pow92.1%
exp-diff92.1%
*-commutative92.1%
exp-to-pow94.1%
sub-neg94.1%
metadata-eval94.1%
Simplified94.1%
Taylor expanded in t around 0 93.9%
*-commutative93.9%
times-frac94.1%
Simplified94.1%
Final simplification93.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* x (pow a (+ t -1.0))) y)))
(if (<= t -9000000.0)
t_1
(if (<= t 6.6e-268)
(/ x (* y (/ a (pow z y))))
(if (<= t 1.08e-222)
(/ (/ x (* a (exp b))) y)
(if (<= t 1.02e-7) (* (/ x (* y (exp b))) (/ (pow z y) a)) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * pow(a, (t + -1.0))) / y;
double tmp;
if (t <= -9000000.0) {
tmp = t_1;
} else if (t <= 6.6e-268) {
tmp = x / (y * (a / pow(z, y)));
} else if (t <= 1.08e-222) {
tmp = (x / (a * exp(b))) / y;
} else if (t <= 1.02e-7) {
tmp = (x / (y * exp(b))) * (pow(z, y) / a);
} 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 * (a ** (t + (-1.0d0)))) / y
if (t <= (-9000000.0d0)) then
tmp = t_1
else if (t <= 6.6d-268) then
tmp = x / (y * (a / (z ** y)))
else if (t <= 1.08d-222) then
tmp = (x / (a * exp(b))) / y
else if (t <= 1.02d-7) then
tmp = (x / (y * exp(b))) * ((z ** y) / a)
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(a, (t + -1.0))) / y;
double tmp;
if (t <= -9000000.0) {
tmp = t_1;
} else if (t <= 6.6e-268) {
tmp = x / (y * (a / Math.pow(z, y)));
} else if (t <= 1.08e-222) {
tmp = (x / (a * Math.exp(b))) / y;
} else if (t <= 1.02e-7) {
tmp = (x / (y * Math.exp(b))) * (Math.pow(z, y) / a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x * math.pow(a, (t + -1.0))) / y tmp = 0 if t <= -9000000.0: tmp = t_1 elif t <= 6.6e-268: tmp = x / (y * (a / math.pow(z, y))) elif t <= 1.08e-222: tmp = (x / (a * math.exp(b))) / y elif t <= 1.02e-7: tmp = (x / (y * math.exp(b))) * (math.pow(z, y) / a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * (a ^ Float64(t + -1.0))) / y) tmp = 0.0 if (t <= -9000000.0) tmp = t_1; elseif (t <= 6.6e-268) tmp = Float64(x / Float64(y * Float64(a / (z ^ y)))); elseif (t <= 1.08e-222) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); elseif (t <= 1.02e-7) tmp = Float64(Float64(x / Float64(y * exp(b))) * Float64((z ^ y) / a)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x * (a ^ (t + -1.0))) / y; tmp = 0.0; if (t <= -9000000.0) tmp = t_1; elseif (t <= 6.6e-268) tmp = x / (y * (a / (z ^ y))); elseif (t <= 1.08e-222) tmp = (x / (a * exp(b))) / y; elseif (t <= 1.02e-7) tmp = (x / (y * exp(b))) * ((z ^ y) / a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t, -9000000.0], t$95$1, If[LessEqual[t, 6.6e-268], N[(x / N[(y * N[(a / N[Power[z, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.08e-222], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 1.02e-7], N[(N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot {a}^{\left(t + -1\right)}}{y}\\
\mathbf{if}\;t \leq -9000000:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 6.6 \cdot 10^{-268}:\\
\;\;\;\;\frac{x}{y \cdot \frac{a}{{z}^{y}}}\\
\mathbf{elif}\;t \leq 1.08 \cdot 10^{-222}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{elif}\;t \leq 1.02 \cdot 10^{-7}:\\
\;\;\;\;\frac{x}{y \cdot e^{b}} \cdot \frac{{z}^{y}}{a}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -9e6 or 1.02e-7 < t Initial program 100.0%
Taylor expanded in y around 0 89.9%
exp-diff73.3%
exp-to-pow73.3%
sub-neg73.3%
metadata-eval73.3%
Simplified73.3%
Taylor expanded in b around 0 85.3%
exp-to-pow85.3%
sub-neg85.3%
metadata-eval85.3%
+-commutative85.3%
Simplified85.3%
if -9e6 < t < 6.59999999999999986e-268Initial program 97.2%
associate-*l/93.3%
associate--l+93.3%
exp-sum76.0%
associate-*r*76.0%
*-commutative76.0%
exp-to-pow76.0%
exp-diff76.0%
*-commutative76.0%
exp-to-pow76.9%
sub-neg76.9%
metadata-eval76.9%
Simplified76.9%
Taylor expanded in t around 0 78.2%
*-commutative78.2%
times-frac79.8%
Simplified79.8%
Taylor expanded in b around 0 78.8%
*-commutative78.8%
clear-num78.8%
frac-times83.1%
*-un-lft-identity83.1%
Applied egg-rr83.1%
if 6.59999999999999986e-268 < t < 1.07999999999999995e-222Initial program 98.3%
Taylor expanded in y around 0 89.8%
exp-diff89.8%
exp-to-pow91.3%
sub-neg91.3%
metadata-eval91.3%
Simplified91.3%
Taylor expanded in t around 0 91.3%
if 1.07999999999999995e-222 < t < 1.02e-7Initial program 98.9%
associate-*l/82.5%
associate--l+82.5%
exp-sum78.4%
associate-*r*78.4%
*-commutative78.4%
exp-to-pow78.4%
exp-diff78.4%
*-commutative78.4%
exp-to-pow79.5%
sub-neg79.5%
metadata-eval79.5%
Simplified79.5%
Taylor expanded in t around 0 87.8%
*-commutative87.8%
times-frac89.7%
Simplified89.7%
Final simplification85.8%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -0.0024) (not (<= y 1.9e+80))) (/ x (* y (/ a (pow z y)))) (/ (* x (/ (pow a (+ t -1.0)) (exp b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -0.0024) || !(y <= 1.9e+80)) {
tmp = x / (y * (a / pow(z, y)));
} else {
tmp = (x * (pow(a, (t + -1.0)) / exp(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 <= (-0.0024d0)) .or. (.not. (y <= 1.9d+80))) then
tmp = x / (y * (a / (z ** y)))
else
tmp = (x * ((a ** (t + (-1.0d0))) / exp(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 <= -0.0024) || !(y <= 1.9e+80)) {
tmp = x / (y * (a / Math.pow(z, y)));
} else {
tmp = (x * (Math.pow(a, (t + -1.0)) / Math.exp(b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -0.0024) or not (y <= 1.9e+80): tmp = x / (y * (a / math.pow(z, y))) else: tmp = (x * (math.pow(a, (t + -1.0)) / math.exp(b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -0.0024) || !(y <= 1.9e+80)) tmp = Float64(x / Float64(y * Float64(a / (z ^ y)))); else tmp = Float64(Float64(x * Float64((a ^ Float64(t + -1.0)) / exp(b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -0.0024) || ~((y <= 1.9e+80))) tmp = x / (y * (a / (z ^ y))); else tmp = (x * ((a ^ (t + -1.0)) / exp(b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -0.0024], N[Not[LessEqual[y, 1.9e+80]], $MachinePrecision]], N[(x / N[(y * N[(a / N[Power[z, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -0.0024 \lor \neg \left(y \leq 1.9 \cdot 10^{+80}\right):\\
\;\;\;\;\frac{x}{y \cdot \frac{a}{{z}^{y}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \frac{{a}^{\left(t + -1\right)}}{e^{b}}}{y}\\
\end{array}
\end{array}
if y < -0.00239999999999999979 or 1.89999999999999999e80 < y Initial program 99.8%
associate-*l/89.8%
associate--l+89.8%
exp-sum59.5%
associate-*r*59.5%
*-commutative59.5%
exp-to-pow59.5%
exp-diff57.9%
*-commutative57.9%
exp-to-pow58.0%
sub-neg58.0%
metadata-eval58.0%
Simplified58.0%
Taylor expanded in t around 0 65.6%
*-commutative65.6%
times-frac69.8%
Simplified69.8%
Taylor expanded in b around 0 78.3%
*-commutative78.3%
clear-num78.3%
frac-times86.8%
*-un-lft-identity86.8%
Applied egg-rr86.8%
if -0.00239999999999999979 < y < 1.89999999999999999e80Initial program 98.2%
Taylor expanded in y around 0 96.1%
exp-diff87.3%
exp-to-pow88.1%
sub-neg88.1%
metadata-eval88.1%
Simplified88.1%
Final simplification87.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* y (/ a (pow z y))))) (t_2 (/ (* x (pow a (+ t -1.0))) y)))
(if (<= y -0.0024)
t_1
(if (<= y -1.25e-110)
(/ (/ x (* a (exp b))) y)
(if (<= y 3.8e-172)
t_2
(if (<= y 4.5e-85)
(/ x (* a (* y (exp b))))
(if (<= y 4.5e-30) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y * (a / pow(z, y)));
double t_2 = (x * pow(a, (t + -1.0))) / y;
double tmp;
if (y <= -0.0024) {
tmp = t_1;
} else if (y <= -1.25e-110) {
tmp = (x / (a * exp(b))) / y;
} else if (y <= 3.8e-172) {
tmp = t_2;
} else if (y <= 4.5e-85) {
tmp = x / (a * (y * exp(b)));
} else if (y <= 4.5e-30) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = x / (y * (a / (z ** y)))
t_2 = (x * (a ** (t + (-1.0d0)))) / y
if (y <= (-0.0024d0)) then
tmp = t_1
else if (y <= (-1.25d-110)) then
tmp = (x / (a * exp(b))) / y
else if (y <= 3.8d-172) then
tmp = t_2
else if (y <= 4.5d-85) then
tmp = x / (a * (y * exp(b)))
else if (y <= 4.5d-30) then
tmp = t_2
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 / (y * (a / Math.pow(z, y)));
double t_2 = (x * Math.pow(a, (t + -1.0))) / y;
double tmp;
if (y <= -0.0024) {
tmp = t_1;
} else if (y <= -1.25e-110) {
tmp = (x / (a * Math.exp(b))) / y;
} else if (y <= 3.8e-172) {
tmp = t_2;
} else if (y <= 4.5e-85) {
tmp = x / (a * (y * Math.exp(b)));
} else if (y <= 4.5e-30) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (y * (a / math.pow(z, y))) t_2 = (x * math.pow(a, (t + -1.0))) / y tmp = 0 if y <= -0.0024: tmp = t_1 elif y <= -1.25e-110: tmp = (x / (a * math.exp(b))) / y elif y <= 3.8e-172: tmp = t_2 elif y <= 4.5e-85: tmp = x / (a * (y * math.exp(b))) elif y <= 4.5e-30: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y * Float64(a / (z ^ y)))) t_2 = Float64(Float64(x * (a ^ Float64(t + -1.0))) / y) tmp = 0.0 if (y <= -0.0024) tmp = t_1; elseif (y <= -1.25e-110) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); elseif (y <= 3.8e-172) tmp = t_2; elseif (y <= 4.5e-85) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); elseif (y <= 4.5e-30) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (y * (a / (z ^ y))); t_2 = (x * (a ^ (t + -1.0))) / y; tmp = 0.0; if (y <= -0.0024) tmp = t_1; elseif (y <= -1.25e-110) tmp = (x / (a * exp(b))) / y; elseif (y <= 3.8e-172) tmp = t_2; elseif (y <= 4.5e-85) tmp = x / (a * (y * exp(b))); elseif (y <= 4.5e-30) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y * N[(a / N[Power[z, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -0.0024], t$95$1, If[LessEqual[y, -1.25e-110], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[y, 3.8e-172], t$95$2, If[LessEqual[y, 4.5e-85], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.5e-30], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y \cdot \frac{a}{{z}^{y}}}\\
t_2 := \frac{x \cdot {a}^{\left(t + -1\right)}}{y}\\
\mathbf{if}\;y \leq -0.0024:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.25 \cdot 10^{-110}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{-172}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-85}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-30}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -0.00239999999999999979 or 4.49999999999999967e-30 < y Initial program 99.8%
associate-*l/91.0%
associate--l+91.0%
exp-sum61.1%
associate-*r*61.1%
*-commutative61.1%
exp-to-pow61.1%
exp-diff59.7%
*-commutative59.7%
exp-to-pow59.9%
sub-neg59.9%
metadata-eval59.9%
Simplified59.9%
Taylor expanded in t around 0 66.5%
*-commutative66.5%
times-frac70.2%
Simplified70.2%
Taylor expanded in b around 0 77.6%
*-commutative77.6%
clear-num77.6%
frac-times84.9%
*-un-lft-identity84.9%
Applied egg-rr84.9%
if -0.00239999999999999979 < y < -1.25e-110Initial program 98.9%
Taylor expanded in y around 0 98.9%
exp-diff90.9%
exp-to-pow91.9%
sub-neg91.9%
metadata-eval91.9%
Simplified91.9%
Taylor expanded in t around 0 84.5%
if -1.25e-110 < y < 3.79999999999999987e-172 or 4.50000000000000004e-85 < y < 4.49999999999999967e-30Initial program 97.4%
Taylor expanded in y around 0 97.4%
exp-diff88.7%
exp-to-pow89.5%
sub-neg89.5%
metadata-eval89.5%
Simplified89.5%
Taylor expanded in b around 0 85.3%
exp-to-pow86.1%
sub-neg86.1%
metadata-eval86.1%
+-commutative86.1%
Simplified86.1%
if 3.79999999999999987e-172 < y < 4.50000000000000004e-85Initial program 99.3%
associate-*l/99.3%
associate--l+99.3%
exp-sum99.3%
associate-*r*99.3%
*-commutative99.3%
exp-to-pow99.3%
exp-diff77.9%
*-commutative77.9%
exp-to-pow78.6%
sub-neg78.6%
metadata-eval78.6%
Simplified78.6%
Taylor expanded in t around 0 86.2%
*-commutative86.2%
times-frac86.2%
Simplified86.2%
Taylor expanded in y around 0 86.2%
Final simplification85.3%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -0.0016) (not (<= y 7e+61))) (/ x (* y (/ a (pow z y)))) (/ x (* a (* y (exp b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -0.0016) || !(y <= 7e+61)) {
tmp = x / (y * (a / pow(z, y)));
} else {
tmp = x / (a * (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 ((y <= (-0.0016d0)) .or. (.not. (y <= 7d+61))) then
tmp = x / (y * (a / (z ** y)))
else
tmp = x / (a * (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 ((y <= -0.0016) || !(y <= 7e+61)) {
tmp = x / (y * (a / Math.pow(z, y)));
} else {
tmp = x / (a * (y * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -0.0016) or not (y <= 7e+61): tmp = x / (y * (a / math.pow(z, y))) else: tmp = x / (a * (y * math.exp(b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -0.0016) || !(y <= 7e+61)) tmp = Float64(x / Float64(y * Float64(a / (z ^ y)))); else tmp = Float64(x / Float64(a * Float64(y * exp(b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -0.0016) || ~((y <= 7e+61))) tmp = x / (y * (a / (z ^ y))); else tmp = x / (a * (y * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -0.0016], N[Not[LessEqual[y, 7e+61]], $MachinePrecision]], N[(x / N[(y * N[(a / N[Power[z, y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -0.0016 \lor \neg \left(y \leq 7 \cdot 10^{+61}\right):\\
\;\;\;\;\frac{x}{y \cdot \frac{a}{{z}^{y}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\end{array}
\end{array}
if y < -0.00160000000000000008 or 7.00000000000000036e61 < y Initial program 99.8%
associate-*l/90.0%
associate--l+90.0%
exp-sum59.7%
associate-*r*59.7%
*-commutative59.7%
exp-to-pow59.7%
exp-diff58.1%
*-commutative58.1%
exp-to-pow58.2%
sub-neg58.2%
metadata-eval58.2%
Simplified58.2%
Taylor expanded in t around 0 65.7%
*-commutative65.7%
times-frac69.8%
Simplified69.8%
Taylor expanded in b around 0 78.0%
*-commutative78.0%
clear-num78.0%
frac-times86.3%
*-un-lft-identity86.3%
Applied egg-rr86.3%
if -0.00160000000000000008 < y < 7.00000000000000036e61Initial program 98.1%
associate-*l/90.2%
associate--l+90.2%
exp-sum87.2%
associate-*r*87.2%
*-commutative87.2%
exp-to-pow87.2%
exp-diff79.0%
*-commutative79.0%
exp-to-pow79.9%
sub-neg79.9%
metadata-eval79.9%
Simplified79.9%
Taylor expanded in t around 0 67.4%
*-commutative67.4%
times-frac65.9%
Simplified65.9%
Taylor expanded in y around 0 68.2%
Final simplification76.8%
(FPCore (x y z t a b) :precision binary64 (if (<= b -31000000.0) (/ x (* a (* y (exp b)))) (if (<= b 2.6e-24) (* (/ (pow z y) a) (/ x y)) (/ (/ x (* a (exp b))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -31000000.0) {
tmp = x / (a * (y * exp(b)));
} else if (b <= 2.6e-24) {
tmp = (pow(z, y) / a) * (x / y);
} else {
tmp = (x / (a * exp(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 (b <= (-31000000.0d0)) then
tmp = x / (a * (y * exp(b)))
else if (b <= 2.6d-24) then
tmp = ((z ** y) / a) * (x / y)
else
tmp = (x / (a * exp(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 (b <= -31000000.0) {
tmp = x / (a * (y * Math.exp(b)));
} else if (b <= 2.6e-24) {
tmp = (Math.pow(z, y) / a) * (x / y);
} else {
tmp = (x / (a * Math.exp(b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -31000000.0: tmp = x / (a * (y * math.exp(b))) elif b <= 2.6e-24: tmp = (math.pow(z, y) / a) * (x / y) else: tmp = (x / (a * math.exp(b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -31000000.0) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); elseif (b <= 2.6e-24) tmp = Float64(Float64((z ^ y) / a) * Float64(x / y)); else tmp = Float64(Float64(x / Float64(a * exp(b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -31000000.0) tmp = x / (a * (y * exp(b))); elseif (b <= 2.6e-24) tmp = ((z ^ y) / a) * (x / y); else tmp = (x / (a * exp(b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -31000000.0], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.6e-24], N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -31000000:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{elif}\;b \leq 2.6 \cdot 10^{-24}:\\
\;\;\;\;\frac{{z}^{y}}{a} \cdot \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\end{array}
\end{array}
if b < -3.1e7Initial program 100.0%
associate-*l/88.1%
associate--l+88.1%
exp-sum66.1%
associate-*r*66.1%
*-commutative66.1%
exp-to-pow66.1%
exp-diff50.8%
*-commutative50.8%
exp-to-pow50.8%
sub-neg50.8%
metadata-eval50.8%
Simplified50.8%
Taylor expanded in t around 0 68.0%
*-commutative68.0%
times-frac68.0%
Simplified68.0%
Taylor expanded in y around 0 78.3%
if -3.1e7 < b < 2.6e-24Initial program 97.8%
associate-*l/92.5%
associate--l+92.5%
exp-sum86.1%
associate-*r*86.1%
*-commutative86.1%
exp-to-pow86.1%
exp-diff86.1%
*-commutative86.1%
exp-to-pow87.2%
sub-neg87.2%
metadata-eval87.2%
Simplified87.2%
Taylor expanded in t around 0 65.7%
*-commutative65.7%
times-frac68.2%
Simplified68.2%
Taylor expanded in b around 0 68.2%
if 2.6e-24 < b Initial program 100.0%
Taylor expanded in y around 0 83.6%
exp-diff72.4%
exp-to-pow72.4%
sub-neg72.4%
metadata-eval72.4%
Simplified72.4%
Taylor expanded in t around 0 78.2%
Final simplification73.3%
(FPCore (x y z t a b) :precision binary64 (/ x (* a (* y (exp b)))))
double code(double x, double y, double z, double t, double a, double b) {
return x / (a * (y * exp(b)));
}
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 * exp(b)))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / (a * (y * Math.exp(b)));
}
def code(x, y, z, t, a, b): return x / (a * (y * math.exp(b)))
function code(x, y, z, t, a, b) return Float64(x / Float64(a * Float64(y * exp(b)))) end
function tmp = code(x, y, z, t, a, b) tmp = x / (a * (y * exp(b))); end
code[x_, y_, z_, t_, a_, b_] := N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{a \cdot \left(y \cdot e^{b}\right)}
\end{array}
Initial program 98.9%
associate-*l/90.1%
associate--l+90.1%
exp-sum74.1%
associate-*r*74.1%
*-commutative74.1%
exp-to-pow74.1%
exp-diff69.0%
*-commutative69.0%
exp-to-pow69.5%
sub-neg69.5%
metadata-eval69.5%
Simplified69.5%
Taylor expanded in t around 0 66.5%
*-commutative66.5%
times-frac67.8%
Simplified67.8%
Taylor expanded in y around 0 55.7%
Final simplification55.7%
(FPCore (x y z t a b) :precision binary64 (/ (/ x (* a (exp b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x / (a * exp(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 / (a * exp(b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x / (a * Math.exp(b))) / y;
}
def code(x, y, z, t, a, b): return (x / (a * math.exp(b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x / Float64(a * exp(b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x / (a * exp(b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{x}{a \cdot e^{b}}}{y}
\end{array}
Initial program 98.9%
Taylor expanded in y around 0 78.1%
exp-diff69.5%
exp-to-pow69.9%
sub-neg69.9%
metadata-eval69.9%
Simplified69.9%
Taylor expanded in t around 0 56.7%
Final simplification56.7%
(FPCore (x y z t a b) :precision binary64 (if (<= b -9.5e-155) (/ (- (* y (/ x y)) (/ (* a b) (/ a x))) (* y a)) (/ (/ x (+ a (* a b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -9.5e-155) {
tmp = ((y * (x / y)) - ((a * b) / (a / x))) / (y * a);
} else {
tmp = (x / (a + (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 (b <= (-9.5d-155)) then
tmp = ((y * (x / y)) - ((a * b) / (a / x))) / (y * a)
else
tmp = (x / (a + (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 (b <= -9.5e-155) {
tmp = ((y * (x / y)) - ((a * b) / (a / x))) / (y * a);
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -9.5e-155: tmp = ((y * (x / y)) - ((a * b) / (a / x))) / (y * a) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -9.5e-155) tmp = Float64(Float64(Float64(y * Float64(x / y)) - Float64(Float64(a * b) / Float64(a / x))) / Float64(y * a)); else tmp = Float64(Float64(x / Float64(a + Float64(a * b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -9.5e-155) tmp = ((y * (x / y)) - ((a * b) / (a / x))) / (y * a); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -9.5e-155], N[(N[(N[(y * N[(x / y), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / N[(a / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{-155}:\\
\;\;\;\;\frac{y \cdot \frac{x}{y} - \frac{a \cdot b}{\frac{a}{x}}}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < -9.50000000000000024e-155Initial program 98.7%
associate-*l/90.1%
associate--l+90.1%
exp-sum75.2%
associate-*r*75.2%
*-commutative75.2%
exp-to-pow75.2%
exp-diff65.6%
*-commutative65.6%
exp-to-pow66.0%
sub-neg66.0%
metadata-eval66.0%
Simplified66.0%
Taylor expanded in t around 0 63.3%
*-commutative63.3%
times-frac64.5%
Simplified64.5%
Taylor expanded in y around 0 58.5%
Taylor expanded in b around 0 29.7%
+-commutative29.7%
mul-1-neg29.7%
unsub-neg29.7%
*-commutative29.7%
*-commutative29.7%
times-frac28.9%
Simplified28.9%
div-inv28.9%
associate-/r*27.9%
associate-*r/26.8%
frac-sub31.8%
div-inv31.8%
Applied egg-rr31.8%
*-commutative31.8%
associate-*l/31.8%
*-commutative31.8%
associate-/l*31.8%
associate-*r/34.8%
*-commutative34.8%
Simplified34.8%
if -9.50000000000000024e-155 < b Initial program 99.1%
Taylor expanded in y around 0 76.4%
exp-diff71.5%
exp-to-pow72.0%
sub-neg72.0%
metadata-eval72.0%
Simplified72.0%
Taylor expanded in t around 0 57.3%
Taylor expanded in b around 0 40.9%
Final simplification38.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.5e+99)
(/ (* b (- x)) (* y a))
(if (<= b -1.58e-289)
(/ x (* y a))
(if (<= b 1.6e+33) (/ (/ x a) y) (/ x (* y (+ a (* a b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.5e+99) {
tmp = (b * -x) / (y * a);
} else if (b <= -1.58e-289) {
tmp = x / (y * a);
} else if (b <= 1.6e+33) {
tmp = (x / a) / y;
} else {
tmp = x / (y * (a + (a * 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 <= (-2.5d+99)) then
tmp = (b * -x) / (y * a)
else if (b <= (-1.58d-289)) then
tmp = x / (y * a)
else if (b <= 1.6d+33) then
tmp = (x / a) / y
else
tmp = x / (y * (a + (a * 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 <= -2.5e+99) {
tmp = (b * -x) / (y * a);
} else if (b <= -1.58e-289) {
tmp = x / (y * a);
} else if (b <= 1.6e+33) {
tmp = (x / a) / y;
} else {
tmp = x / (y * (a + (a * b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.5e+99: tmp = (b * -x) / (y * a) elif b <= -1.58e-289: tmp = x / (y * a) elif b <= 1.6e+33: tmp = (x / a) / y else: tmp = x / (y * (a + (a * b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.5e+99) tmp = Float64(Float64(b * Float64(-x)) / Float64(y * a)); elseif (b <= -1.58e-289) tmp = Float64(x / Float64(y * a)); elseif (b <= 1.6e+33) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(y * Float64(a + Float64(a * b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.5e+99) tmp = (b * -x) / (y * a); elseif (b <= -1.58e-289) tmp = x / (y * a); elseif (b <= 1.6e+33) tmp = (x / a) / y; else tmp = x / (y * (a + (a * b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.5e+99], N[(N[(b * (-x)), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.58e-289], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.6e+33], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(y * N[(a + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.5 \cdot 10^{+99}:\\
\;\;\;\;\frac{b \cdot \left(-x\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq -1.58 \cdot 10^{-289}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{elif}\;b \leq 1.6 \cdot 10^{+33}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(a + a \cdot b\right)}\\
\end{array}
\end{array}
if b < -2.50000000000000004e99Initial program 100.0%
associate-*l/89.7%
associate--l+89.7%
exp-sum69.2%
associate-*r*69.2%
*-commutative69.2%
exp-to-pow69.2%
exp-diff51.3%
*-commutative51.3%
exp-to-pow51.3%
sub-neg51.3%
metadata-eval51.3%
Simplified51.3%
Taylor expanded in t around 0 71.9%
*-commutative71.9%
times-frac71.9%
Simplified71.9%
Taylor expanded in y around 0 87.4%
Taylor expanded in b around 0 42.7%
+-commutative42.7%
mul-1-neg42.7%
unsub-neg42.7%
*-commutative42.7%
*-commutative42.7%
times-frac35.5%
Simplified35.5%
Taylor expanded in b around inf 42.7%
neg-mul-142.7%
distribute-neg-frac42.7%
distribute-rgt-neg-out42.7%
*-commutative42.7%
Simplified42.7%
if -2.50000000000000004e99 < b < -1.5799999999999999e-289Initial program 98.0%
associate-*l/89.2%
associate--l+89.2%
exp-sum79.1%
associate-*r*79.1%
*-commutative79.1%
exp-to-pow79.1%
exp-diff76.6%
*-commutative76.6%
exp-to-pow77.3%
sub-neg77.3%
metadata-eval77.3%
Simplified77.3%
Taylor expanded in t around 0 59.1%
*-commutative59.1%
times-frac56.9%
Simplified56.9%
Taylor expanded in y around 0 39.9%
Taylor expanded in b around 0 31.4%
*-commutative31.4%
Simplified31.4%
if -1.5799999999999999e-289 < b < 1.60000000000000009e33Initial program 98.6%
Taylor expanded in y around 0 69.3%
exp-diff68.0%
exp-to-pow68.8%
sub-neg68.8%
metadata-eval68.8%
Simplified68.8%
Taylor expanded in t around 0 44.5%
Taylor expanded in b around 0 42.0%
if 1.60000000000000009e33 < b Initial program 100.0%
Taylor expanded in y around 0 83.3%
exp-diff71.3%
exp-to-pow71.3%
sub-neg71.3%
metadata-eval71.3%
Simplified71.3%
Taylor expanded in t around 0 81.6%
Taylor expanded in b around 0 39.7%
Taylor expanded in x around 0 44.4%
Final simplification39.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.6e+99)
(/ (- (/ x y) (* x (/ b y))) a)
(if (<= b 1.52e-297)
(/ x (* y a))
(if (<= b 1.05e-232) (/ (/ x (* a b)) y) (/ (/ x (+ a (* a b))) y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.6e+99) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= 1.52e-297) {
tmp = x / (y * a);
} else if (b <= 1.05e-232) {
tmp = (x / (a * b)) / y;
} else {
tmp = (x / (a + (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 (b <= (-2.6d+99)) then
tmp = ((x / y) - (x * (b / y))) / a
else if (b <= 1.52d-297) then
tmp = x / (y * a)
else if (b <= 1.05d-232) then
tmp = (x / (a * b)) / y
else
tmp = (x / (a + (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 (b <= -2.6e+99) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= 1.52e-297) {
tmp = x / (y * a);
} else if (b <= 1.05e-232) {
tmp = (x / (a * b)) / y;
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.6e+99: tmp = ((x / y) - (x * (b / y))) / a elif b <= 1.52e-297: tmp = x / (y * a) elif b <= 1.05e-232: tmp = (x / (a * b)) / y else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.6e+99) tmp = Float64(Float64(Float64(x / y) - Float64(x * Float64(b / y))) / a); elseif (b <= 1.52e-297) tmp = Float64(x / Float64(y * a)); elseif (b <= 1.05e-232) tmp = Float64(Float64(x / Float64(a * b)) / y); else tmp = Float64(Float64(x / Float64(a + Float64(a * b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.6e+99) tmp = ((x / y) - (x * (b / y))) / a; elseif (b <= 1.52e-297) tmp = x / (y * a); elseif (b <= 1.05e-232) tmp = (x / (a * b)) / y; else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.6e+99], N[(N[(N[(x / y), $MachinePrecision] - N[(x * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, 1.52e-297], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.05e-232], N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / N[(a + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.6 \cdot 10^{+99}:\\
\;\;\;\;\frac{\frac{x}{y} - x \cdot \frac{b}{y}}{a}\\
\mathbf{elif}\;b \leq 1.52 \cdot 10^{-297}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{elif}\;b \leq 1.05 \cdot 10^{-232}:\\
\;\;\;\;\frac{\frac{x}{a \cdot b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < -2.6e99Initial program 100.0%
associate-*l/89.7%
associate--l+89.7%
exp-sum69.2%
associate-*r*69.2%
*-commutative69.2%
exp-to-pow69.2%
exp-diff51.3%
*-commutative51.3%
exp-to-pow51.3%
sub-neg51.3%
metadata-eval51.3%
Simplified51.3%
Taylor expanded in t around 0 71.9%
*-commutative71.9%
times-frac71.9%
Simplified71.9%
Taylor expanded in y around 0 87.4%
Taylor expanded in b around 0 42.7%
+-commutative42.7%
mul-1-neg42.7%
unsub-neg42.7%
*-commutative42.7%
*-commutative42.7%
times-frac35.5%
Simplified35.5%
associate-*l/45.3%
associate-/r*45.3%
sub-div45.3%
Applied egg-rr45.3%
if -2.6e99 < b < 1.52e-297Initial program 98.0%
associate-*l/90.0%
associate--l+90.0%
exp-sum81.0%
associate-*r*81.0%
*-commutative81.0%
exp-to-pow81.0%
exp-diff78.7%
*-commutative78.7%
exp-to-pow79.6%
sub-neg79.6%
metadata-eval79.6%
Simplified79.6%
Taylor expanded in t around 0 58.9%
*-commutative58.9%
times-frac57.9%
Simplified57.9%
Taylor expanded in y around 0 40.5%
Taylor expanded in b around 0 32.9%
*-commutative32.9%
Simplified32.9%
if 1.52e-297 < b < 1.05e-232Initial program 99.4%
Taylor expanded in y around 0 68.8%
exp-diff68.8%
exp-to-pow69.4%
sub-neg69.4%
metadata-eval69.4%
Simplified69.4%
Taylor expanded in t around 0 27.5%
Taylor expanded in b around 0 27.5%
Taylor expanded in b around inf 39.1%
if 1.05e-232 < b Initial program 99.3%
Taylor expanded in y around 0 74.4%
exp-diff67.3%
exp-to-pow67.5%
sub-neg67.5%
metadata-eval67.5%
Simplified67.5%
Taylor expanded in t around 0 66.2%
Taylor expanded in b around 0 42.6%
Final simplification39.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -5e+102)
(/ (* b (- x)) (* y a))
(if (<= b -7.6e-290)
(/ x (* y a))
(if (<= b 1.4e+33) (/ (/ x a) y) (/ x (* a (* y b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -5e+102) {
tmp = (b * -x) / (y * a);
} else if (b <= -7.6e-290) {
tmp = x / (y * a);
} else if (b <= 1.4e+33) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * 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 <= (-5d+102)) then
tmp = (b * -x) / (y * a)
else if (b <= (-7.6d-290)) then
tmp = x / (y * a)
else if (b <= 1.4d+33) then
tmp = (x / a) / y
else
tmp = x / (a * (y * 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 <= -5e+102) {
tmp = (b * -x) / (y * a);
} else if (b <= -7.6e-290) {
tmp = x / (y * a);
} else if (b <= 1.4e+33) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -5e+102: tmp = (b * -x) / (y * a) elif b <= -7.6e-290: tmp = x / (y * a) elif b <= 1.4e+33: tmp = (x / a) / y else: tmp = x / (a * (y * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -5e+102) tmp = Float64(Float64(b * Float64(-x)) / Float64(y * a)); elseif (b <= -7.6e-290) tmp = Float64(x / Float64(y * a)); elseif (b <= 1.4e+33) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(a * Float64(y * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -5e+102) tmp = (b * -x) / (y * a); elseif (b <= -7.6e-290) tmp = x / (y * a); elseif (b <= 1.4e+33) tmp = (x / a) / y; else tmp = x / (a * (y * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -5e+102], N[(N[(b * (-x)), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -7.6e-290], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.4e+33], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -5 \cdot 10^{+102}:\\
\;\;\;\;\frac{b \cdot \left(-x\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq -7.6 \cdot 10^{-290}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{elif}\;b \leq 1.4 \cdot 10^{+33}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < -5e102Initial program 100.0%
associate-*l/89.7%
associate--l+89.7%
exp-sum69.2%
associate-*r*69.2%
*-commutative69.2%
exp-to-pow69.2%
exp-diff51.3%
*-commutative51.3%
exp-to-pow51.3%
sub-neg51.3%
metadata-eval51.3%
Simplified51.3%
Taylor expanded in t around 0 71.9%
*-commutative71.9%
times-frac71.9%
Simplified71.9%
Taylor expanded in y around 0 87.4%
Taylor expanded in b around 0 42.7%
+-commutative42.7%
mul-1-neg42.7%
unsub-neg42.7%
*-commutative42.7%
*-commutative42.7%
times-frac35.5%
Simplified35.5%
Taylor expanded in b around inf 42.7%
neg-mul-142.7%
distribute-neg-frac42.7%
distribute-rgt-neg-out42.7%
*-commutative42.7%
Simplified42.7%
if -5e102 < b < -7.5999999999999995e-290Initial program 98.0%
associate-*l/89.2%
associate--l+89.2%
exp-sum79.1%
associate-*r*79.1%
*-commutative79.1%
exp-to-pow79.1%
exp-diff76.6%
*-commutative76.6%
exp-to-pow77.3%
sub-neg77.3%
metadata-eval77.3%
Simplified77.3%
Taylor expanded in t around 0 59.1%
*-commutative59.1%
times-frac56.9%
Simplified56.9%
Taylor expanded in y around 0 39.9%
Taylor expanded in b around 0 31.4%
*-commutative31.4%
Simplified31.4%
if -7.5999999999999995e-290 < b < 1.4e33Initial program 98.6%
Taylor expanded in y around 0 69.3%
exp-diff68.0%
exp-to-pow68.8%
sub-neg68.8%
metadata-eval68.8%
Simplified68.8%
Taylor expanded in t around 0 44.5%
Taylor expanded in b around 0 42.0%
if 1.4e33 < b Initial program 100.0%
Taylor expanded in y around 0 83.3%
exp-diff71.3%
exp-to-pow71.3%
sub-neg71.3%
metadata-eval71.3%
Simplified71.3%
Taylor expanded in t around 0 81.6%
Taylor expanded in b around 0 39.7%
Taylor expanded in b around inf 42.3%
*-commutative42.3%
Simplified42.3%
Final simplification38.9%
(FPCore (x y z t a b) :precision binary64 (if (<= b -8.6e+100) (/ (* b (- x)) (* y a)) (if (<= b -8e-284) (/ x (* y a)) (/ (/ x (+ a (* a b))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -8.6e+100) {
tmp = (b * -x) / (y * a);
} else if (b <= -8e-284) {
tmp = x / (y * a);
} else {
tmp = (x / (a + (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 (b <= (-8.6d+100)) then
tmp = (b * -x) / (y * a)
else if (b <= (-8d-284)) then
tmp = x / (y * a)
else
tmp = (x / (a + (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 (b <= -8.6e+100) {
tmp = (b * -x) / (y * a);
} else if (b <= -8e-284) {
tmp = x / (y * a);
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -8.6e+100: tmp = (b * -x) / (y * a) elif b <= -8e-284: tmp = x / (y * a) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -8.6e+100) tmp = Float64(Float64(b * Float64(-x)) / Float64(y * a)); elseif (b <= -8e-284) tmp = Float64(x / Float64(y * a)); else tmp = Float64(Float64(x / Float64(a + Float64(a * b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -8.6e+100) tmp = (b * -x) / (y * a); elseif (b <= -8e-284) tmp = x / (y * a); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -8.6e+100], N[(N[(b * (-x)), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -8e-284], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -8.6 \cdot 10^{+100}:\\
\;\;\;\;\frac{b \cdot \left(-x\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq -8 \cdot 10^{-284}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < -8.59999999999999986e100Initial program 100.0%
associate-*l/89.7%
associate--l+89.7%
exp-sum69.2%
associate-*r*69.2%
*-commutative69.2%
exp-to-pow69.2%
exp-diff51.3%
*-commutative51.3%
exp-to-pow51.3%
sub-neg51.3%
metadata-eval51.3%
Simplified51.3%
Taylor expanded in t around 0 71.9%
*-commutative71.9%
times-frac71.9%
Simplified71.9%
Taylor expanded in y around 0 87.4%
Taylor expanded in b around 0 42.7%
+-commutative42.7%
mul-1-neg42.7%
unsub-neg42.7%
*-commutative42.7%
*-commutative42.7%
times-frac35.5%
Simplified35.5%
Taylor expanded in b around inf 42.7%
neg-mul-142.7%
distribute-neg-frac42.7%
distribute-rgt-neg-out42.7%
*-commutative42.7%
Simplified42.7%
if -8.59999999999999986e100 < b < -8.00000000000000029e-284Initial program 98.1%
associate-*l/89.1%
associate--l+89.1%
exp-sum78.9%
associate-*r*78.9%
*-commutative78.9%
exp-to-pow78.9%
exp-diff76.3%
*-commutative76.3%
exp-to-pow77.0%
sub-neg77.0%
metadata-eval77.0%
Simplified77.0%
Taylor expanded in t around 0 58.6%
*-commutative58.6%
times-frac56.3%
Simplified56.3%
Taylor expanded in y around 0 40.2%
Taylor expanded in b around 0 31.6%
*-commutative31.6%
Simplified31.6%
if -8.00000000000000029e-284 < b Initial program 99.1%
Taylor expanded in y around 0 74.9%
exp-diff69.1%
exp-to-pow69.5%
sub-neg69.5%
metadata-eval69.5%
Simplified69.5%
Taylor expanded in t around 0 60.0%
Taylor expanded in b around 0 40.9%
Final simplification38.3%
(FPCore (x y z t a b) :precision binary64 (if (<= b -2.15e-284) (* x (/ 1.0 (* y a))) (if (<= b 3.5e+33) (/ (/ x a) y) (/ x (* a (* y b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.15e-284) {
tmp = x * (1.0 / (y * a));
} else if (b <= 3.5e+33) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * 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 <= (-2.15d-284)) then
tmp = x * (1.0d0 / (y * a))
else if (b <= 3.5d+33) then
tmp = (x / a) / y
else
tmp = x / (a * (y * 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 <= -2.15e-284) {
tmp = x * (1.0 / (y * a));
} else if (b <= 3.5e+33) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.15e-284: tmp = x * (1.0 / (y * a)) elif b <= 3.5e+33: tmp = (x / a) / y else: tmp = x / (a * (y * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.15e-284) tmp = Float64(x * Float64(1.0 / Float64(y * a))); elseif (b <= 3.5e+33) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(a * Float64(y * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.15e-284) tmp = x * (1.0 / (y * a)); elseif (b <= 3.5e+33) tmp = (x / a) / y; else tmp = x / (a * (y * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.15e-284], N[(x * N[(1.0 / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.5e+33], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.15 \cdot 10^{-284}:\\
\;\;\;\;x \cdot \frac{1}{y \cdot a}\\
\mathbf{elif}\;b \leq 3.5 \cdot 10^{+33}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < -2.1500000000000001e-284Initial program 98.8%
associate-*l/89.3%
associate--l+89.3%
exp-sum75.7%
associate-*r*75.7%
*-commutative75.7%
exp-to-pow75.7%
exp-diff68.0%
*-commutative68.0%
exp-to-pow68.4%
sub-neg68.4%
metadata-eval68.4%
Simplified68.4%
Taylor expanded in t around 0 63.0%
*-commutative63.0%
times-frac61.5%
Simplified61.5%
Taylor expanded in y around 0 55.9%
Taylor expanded in b around 0 24.7%
*-commutative24.7%
Simplified24.7%
div-inv25.4%
/-rgt-identity25.4%
clear-num25.4%
div-inv25.4%
div-inv25.4%
clear-num25.4%
/-rgt-identity25.4%
*-commutative25.4%
Applied egg-rr25.4%
if -2.1500000000000001e-284 < b < 3.5000000000000001e33Initial program 98.5%
Taylor expanded in y around 0 68.6%
exp-diff67.4%
exp-to-pow68.1%
sub-neg68.1%
metadata-eval68.1%
Simplified68.1%
Taylor expanded in t around 0 44.1%
Taylor expanded in b around 0 41.7%
if 3.5000000000000001e33 < b Initial program 100.0%
Taylor expanded in y around 0 83.3%
exp-diff71.3%
exp-to-pow71.3%
sub-neg71.3%
metadata-eval71.3%
Simplified71.3%
Taylor expanded in t around 0 81.6%
Taylor expanded in b around 0 39.7%
Taylor expanded in b around inf 42.3%
*-commutative42.3%
Simplified42.3%
Final simplification34.4%
(FPCore (x y z t a b) :precision binary64 (if (<= b -3.7e-154) (* x (/ (- b) (* y a))) (if (<= b 8.5e+32) (/ (/ x a) y) (/ x (* a (* y b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -3.7e-154) {
tmp = x * (-b / (y * a));
} else if (b <= 8.5e+32) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * 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 <= (-3.7d-154)) then
tmp = x * (-b / (y * a))
else if (b <= 8.5d+32) then
tmp = (x / a) / y
else
tmp = x / (a * (y * 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 <= -3.7e-154) {
tmp = x * (-b / (y * a));
} else if (b <= 8.5e+32) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -3.7e-154: tmp = x * (-b / (y * a)) elif b <= 8.5e+32: tmp = (x / a) / y else: tmp = x / (a * (y * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -3.7e-154) tmp = Float64(x * Float64(Float64(-b) / Float64(y * a))); elseif (b <= 8.5e+32) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(a * Float64(y * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -3.7e-154) tmp = x * (-b / (y * a)); elseif (b <= 8.5e+32) tmp = (x / a) / y; else tmp = x / (a * (y * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -3.7e-154], N[(x * N[((-b) / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 8.5e+32], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.7 \cdot 10^{-154}:\\
\;\;\;\;x \cdot \frac{-b}{y \cdot a}\\
\mathbf{elif}\;b \leq 8.5 \cdot 10^{+32}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < -3.69999999999999987e-154Initial program 98.7%
associate-*l/90.1%
associate--l+90.1%
exp-sum75.2%
associate-*r*75.2%
*-commutative75.2%
exp-to-pow75.2%
exp-diff65.6%
*-commutative65.6%
exp-to-pow66.0%
sub-neg66.0%
metadata-eval66.0%
Simplified66.0%
Taylor expanded in t around 0 63.3%
*-commutative63.3%
times-frac64.5%
Simplified64.5%
Taylor expanded in y around 0 58.5%
Taylor expanded in b around 0 29.7%
+-commutative29.7%
mul-1-neg29.7%
unsub-neg29.7%
*-commutative29.7%
*-commutative29.7%
times-frac28.9%
Simplified28.9%
Taylor expanded in b around inf 26.0%
associate-*r/26.0%
*-commutative26.0%
neg-mul-126.0%
distribute-rgt-neg-in26.0%
associate-*r/28.2%
*-commutative28.2%
Simplified28.2%
if -3.69999999999999987e-154 < b < 8.4999999999999998e32Initial program 98.5%
Taylor expanded in y around 0 72.5%
exp-diff71.5%
exp-to-pow72.4%
sub-neg72.4%
metadata-eval72.4%
Simplified72.4%
Taylor expanded in t around 0 43.4%
Taylor expanded in b around 0 41.5%
if 8.4999999999999998e32 < b Initial program 100.0%
Taylor expanded in y around 0 83.3%
exp-diff71.3%
exp-to-pow71.3%
sub-neg71.3%
metadata-eval71.3%
Simplified71.3%
Taylor expanded in t around 0 81.6%
Taylor expanded in b around 0 39.7%
Taylor expanded in b around inf 42.3%
*-commutative42.3%
Simplified42.3%
Final simplification36.8%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.1e-280) (* x (/ 1.0 (* y a))) (/ (/ x a) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.1e-280) {
tmp = x * (1.0 / (y * a));
} 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.1d-280)) then
tmp = x * (1.0d0 / (y * a))
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.1e-280) {
tmp = x * (1.0 / (y * a));
} else {
tmp = (x / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.1e-280: tmp = x * (1.0 / (y * a)) else: tmp = (x / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.1e-280) tmp = Float64(x * Float64(1.0 / Float64(y * a))); 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.1e-280) tmp = x * (1.0 / (y * a)); else tmp = (x / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.1e-280], N[(x * N[(1.0 / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.1 \cdot 10^{-280}:\\
\;\;\;\;x \cdot \frac{1}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\end{array}
\end{array}
if b < -1.1000000000000001e-280Initial program 98.8%
associate-*l/89.3%
associate--l+89.3%
exp-sum75.7%
associate-*r*75.7%
*-commutative75.7%
exp-to-pow75.7%
exp-diff68.0%
*-commutative68.0%
exp-to-pow68.4%
sub-neg68.4%
metadata-eval68.4%
Simplified68.4%
Taylor expanded in t around 0 63.0%
*-commutative63.0%
times-frac61.5%
Simplified61.5%
Taylor expanded in y around 0 55.9%
Taylor expanded in b around 0 24.7%
*-commutative24.7%
Simplified24.7%
div-inv25.4%
/-rgt-identity25.4%
clear-num25.4%
div-inv25.4%
div-inv25.4%
clear-num25.4%
/-rgt-identity25.4%
*-commutative25.4%
Applied egg-rr25.4%
if -1.1000000000000001e-280 < b Initial program 99.1%
Taylor expanded in y around 0 74.9%
exp-diff69.1%
exp-to-pow69.5%
sub-neg69.5%
metadata-eval69.5%
Simplified69.5%
Taylor expanded in t around 0 60.0%
Taylor expanded in b around 0 31.8%
Final simplification28.9%
(FPCore (x y z t a b) :precision binary64 (if (<= b -4.5e-278) (/ x (* y a)) (/ (/ x a) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -4.5e-278) {
tmp = x / (y * a);
} 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 <= (-4.5d-278)) then
tmp = x / (y * a)
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 <= -4.5e-278) {
tmp = x / (y * a);
} else {
tmp = (x / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -4.5e-278: tmp = x / (y * a) else: tmp = (x / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -4.5e-278) tmp = Float64(x / Float64(y * a)); 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 <= -4.5e-278) tmp = x / (y * a); else tmp = (x / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -4.5e-278], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4.5 \cdot 10^{-278}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\end{array}
\end{array}
if b < -4.4999999999999998e-278Initial program 98.8%
associate-*l/89.3%
associate--l+89.3%
exp-sum75.7%
associate-*r*75.7%
*-commutative75.7%
exp-to-pow75.7%
exp-diff68.0%
*-commutative68.0%
exp-to-pow68.4%
sub-neg68.4%
metadata-eval68.4%
Simplified68.4%
Taylor expanded in t around 0 63.0%
*-commutative63.0%
times-frac61.5%
Simplified61.5%
Taylor expanded in y around 0 55.9%
Taylor expanded in b around 0 24.7%
*-commutative24.7%
Simplified24.7%
if -4.4999999999999998e-278 < b Initial program 99.1%
Taylor expanded in y around 0 74.9%
exp-diff69.1%
exp-to-pow69.5%
sub-neg69.5%
metadata-eval69.5%
Simplified69.5%
Taylor expanded in t around 0 60.0%
Taylor expanded in b around 0 31.8%
Final simplification28.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 98.9%
associate-*l/90.1%
associate--l+90.1%
exp-sum74.1%
associate-*r*74.1%
*-commutative74.1%
exp-to-pow74.1%
exp-diff69.0%
*-commutative69.0%
exp-to-pow69.5%
sub-neg69.5%
metadata-eval69.5%
Simplified69.5%
Taylor expanded in t around 0 66.5%
*-commutative66.5%
times-frac67.8%
Simplified67.8%
Taylor expanded in y around 0 55.7%
Taylor expanded in b around 0 26.1%
*-commutative26.1%
Simplified26.1%
Final simplification26.1%
(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 2023340
(FPCore (x y z t a b)
:name "Numeric.SpecFunctions:incompleteBetaWorker from math-functions-0.1.5.2, A"
:precision binary64
:herbie-target
(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))