
(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 27 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 98.5%
Final simplification98.5%
(FPCore (x y z t a b) :precision binary64 (if (or (<= (+ t -1.0) -1e+34) (not (<= (+ t -1.0) 8000000.0))) (/ (* x (exp (- (* (+ t -1.0) (log a)) b))) y) (/ (* x (exp (- (- (* y (log z)) (log a)) b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (((t + -1.0) <= -1e+34) || !((t + -1.0) <= 8000000.0)) {
tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y;
} else {
tmp = (x * exp((((y * log(z)) - 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 (((t + (-1.0d0)) <= (-1d+34)) .or. (.not. ((t + (-1.0d0)) <= 8000000.0d0))) then
tmp = (x * exp((((t + (-1.0d0)) * log(a)) - b))) / y
else
tmp = (x * exp((((y * log(z)) - 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 (((t + -1.0) <= -1e+34) || !((t + -1.0) <= 8000000.0)) {
tmp = (x * Math.exp((((t + -1.0) * Math.log(a)) - b))) / y;
} else {
tmp = (x * Math.exp((((y * Math.log(z)) - Math.log(a)) - b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if ((t + -1.0) <= -1e+34) or not ((t + -1.0) <= 8000000.0): tmp = (x * math.exp((((t + -1.0) * math.log(a)) - b))) / y else: tmp = (x * math.exp((((y * math.log(z)) - math.log(a)) - b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((Float64(t + -1.0) <= -1e+34) || !(Float64(t + -1.0) <= 8000000.0)) tmp = Float64(Float64(x * exp(Float64(Float64(Float64(t + -1.0) * log(a)) - b))) / y); else tmp = Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) - log(a)) - b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (((t + -1.0) <= -1e+34) || ~(((t + -1.0) <= 8000000.0))) tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y; else tmp = (x * exp((((y * log(z)) - log(a)) - b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[N[(t + -1.0), $MachinePrecision], -1e+34], N[Not[LessEqual[N[(t + -1.0), $MachinePrecision], 8000000.0]], $MachinePrecision]], N[(N[(x * N[Exp[N[(N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $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]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t + -1 \leq -1 \cdot 10^{+34} \lor \neg \left(t + -1 \leq 8000000\right):\\
\;\;\;\;\frac{x \cdot e^{\left(t + -1\right) \cdot \log a - b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\left(y \cdot \log z - \log a\right) - b}}{y}\\
\end{array}
\end{array}
if (-.f64 t #s(literal 1 binary64)) < -9.99999999999999946e33 or 8e6 < (-.f64 t #s(literal 1 binary64)) Initial program 100.0%
Taylor expanded in y around 0 91.9%
if -9.99999999999999946e33 < (-.f64 t #s(literal 1 binary64)) < 8e6Initial program 97.4%
Taylor expanded in t around 0 97.4%
+-commutative97.4%
mul-1-neg97.4%
unsub-neg97.4%
Simplified97.4%
Final simplification95.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (/ (pow z y) a) y))) (t_2 (/ (pow a (+ t -1.0)) y)))
(if (<= y -6000000.0)
t_1
(if (<= y -1.15e-195)
(/ (/ x (* a (exp b))) y)
(if (<= y 8.8e-240)
(* x t_2)
(if (<= y 3.4e+49) (* x (/ t_2 (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 t_2 = pow(a, (t + -1.0)) / y;
double tmp;
if (y <= -6000000.0) {
tmp = t_1;
} else if (y <= -1.15e-195) {
tmp = (x / (a * exp(b))) / y;
} else if (y <= 8.8e-240) {
tmp = x * t_2;
} else if (y <= 3.4e+49) {
tmp = x * (t_2 / 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) :: t_2
real(8) :: tmp
t_1 = x * (((z ** y) / a) / y)
t_2 = (a ** (t + (-1.0d0))) / y
if (y <= (-6000000.0d0)) then
tmp = t_1
else if (y <= (-1.15d-195)) then
tmp = (x / (a * exp(b))) / y
else if (y <= 8.8d-240) then
tmp = x * t_2
else if (y <= 3.4d+49) then
tmp = x * (t_2 / 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 t_2 = Math.pow(a, (t + -1.0)) / y;
double tmp;
if (y <= -6000000.0) {
tmp = t_1;
} else if (y <= -1.15e-195) {
tmp = (x / (a * Math.exp(b))) / y;
} else if (y <= 8.8e-240) {
tmp = x * t_2;
} else if (y <= 3.4e+49) {
tmp = x * (t_2 / 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) t_2 = math.pow(a, (t + -1.0)) / y tmp = 0 if y <= -6000000.0: tmp = t_1 elif y <= -1.15e-195: tmp = (x / (a * math.exp(b))) / y elif y <= 8.8e-240: tmp = x * t_2 elif y <= 3.4e+49: tmp = x * (t_2 / 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)) t_2 = Float64((a ^ Float64(t + -1.0)) / y) tmp = 0.0 if (y <= -6000000.0) tmp = t_1; elseif (y <= -1.15e-195) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); elseif (y <= 8.8e-240) tmp = Float64(x * t_2); elseif (y <= 3.4e+49) tmp = Float64(x * Float64(t_2 / 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); t_2 = (a ^ (t + -1.0)) / y; tmp = 0.0; if (y <= -6000000.0) tmp = t_1; elseif (y <= -1.15e-195) tmp = (x / (a * exp(b))) / y; elseif (y <= 8.8e-240) tmp = x * t_2; elseif (y <= 3.4e+49) tmp = x * (t_2 / 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]}, Block[{t$95$2 = N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -6000000.0], t$95$1, If[LessEqual[y, -1.15e-195], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[y, 8.8e-240], N[(x * t$95$2), $MachinePrecision], If[LessEqual[y, 3.4e+49], N[(x * N[(t$95$2 / N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{\frac{{z}^{y}}{a}}{y}\\
t_2 := \frac{{a}^{\left(t + -1\right)}}{y}\\
\mathbf{if}\;y \leq -6000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1.15 \cdot 10^{-195}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{elif}\;y \leq 8.8 \cdot 10^{-240}:\\
\;\;\;\;x \cdot t\_2\\
\mathbf{elif}\;y \leq 3.4 \cdot 10^{+49}:\\
\;\;\;\;x \cdot \frac{t\_2}{e^{b}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -6e6 or 3.4000000000000001e49 < y Initial program 100.0%
Taylor expanded in t around 0 93.1%
+-commutative93.1%
mul-1-neg93.1%
unsub-neg93.1%
Simplified93.1%
Taylor expanded in b around 0 82.7%
*-commutative82.7%
div-exp82.7%
*-commutative82.7%
exp-to-pow82.7%
rem-exp-log82.7%
Simplified82.7%
*-commutative82.7%
associate-/l*82.7%
Applied egg-rr82.7%
if -6e6 < y < -1.1500000000000001e-195Initial program 98.4%
Taylor expanded in y around 0 98.4%
div-exp86.7%
exp-to-pow88.1%
sub-neg88.1%
metadata-eval88.1%
Simplified88.1%
Taylor expanded in t around 0 82.8%
if -1.1500000000000001e-195 < y < 8.7999999999999997e-240Initial program 95.8%
associate-/l*93.6%
associate--l+93.6%
exp-sum93.6%
associate-/l*93.6%
*-commutative93.6%
exp-to-pow93.6%
exp-diff76.9%
*-commutative76.9%
exp-to-pow77.9%
sub-neg77.9%
metadata-eval77.9%
Simplified77.9%
Taylor expanded in y around 0 76.9%
associate-/r*74.2%
exp-to-pow75.2%
sub-neg75.2%
metadata-eval75.2%
Simplified75.2%
Taylor expanded in b around 0 86.2%
Simplified87.0%
if 8.7999999999999997e-240 < y < 3.4000000000000001e49Initial program 97.5%
associate-/l*96.3%
associate--l+96.3%
exp-sum89.4%
associate-/l*89.4%
*-commutative89.4%
exp-to-pow89.4%
exp-diff79.7%
*-commutative79.7%
exp-to-pow80.6%
sub-neg80.6%
metadata-eval80.6%
Simplified80.6%
Taylor expanded in y around 0 82.0%
associate-/r*82.0%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Final simplification83.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (/ (pow z y) a) y))))
(if (<= y -6500000.0)
t_1
(if (<= y -8e-68)
(/ x (* a (* y (exp b))))
(if (<= y 3.8e+49) (/ (* x (/ (pow a (+ t -1.0)) (exp b))) y) 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 <= -6500000.0) {
tmp = t_1;
} else if (y <= -8e-68) {
tmp = x / (a * (y * exp(b)));
} else if (y <= 3.8e+49) {
tmp = (x * (pow(a, (t + -1.0)) / exp(b))) / y;
} 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 <= (-6500000.0d0)) then
tmp = t_1
else if (y <= (-8d-68)) then
tmp = x / (a * (y * exp(b)))
else if (y <= 3.8d+49) then
tmp = (x * ((a ** (t + (-1.0d0))) / exp(b))) / y
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 <= -6500000.0) {
tmp = t_1;
} else if (y <= -8e-68) {
tmp = x / (a * (y * Math.exp(b)));
} else if (y <= 3.8e+49) {
tmp = (x * (Math.pow(a, (t + -1.0)) / Math.exp(b))) / y;
} 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 <= -6500000.0: tmp = t_1 elif y <= -8e-68: tmp = x / (a * (y * math.exp(b))) elif y <= 3.8e+49: tmp = (x * (math.pow(a, (t + -1.0)) / math.exp(b))) / y 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 <= -6500000.0) tmp = t_1; elseif (y <= -8e-68) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); elseif (y <= 3.8e+49) tmp = Float64(Float64(x * Float64((a ^ Float64(t + -1.0)) / exp(b))) / y); 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 <= -6500000.0) tmp = t_1; elseif (y <= -8e-68) tmp = x / (a * (y * exp(b))); elseif (y <= 3.8e+49) tmp = (x * ((a ^ (t + -1.0)) / exp(b))) / y; 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, -6500000.0], t$95$1, If[LessEqual[y, -8e-68], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.8e+49], N[(N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{\frac{{z}^{y}}{a}}{y}\\
\mathbf{if}\;y \leq -6500000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -8 \cdot 10^{-68}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{+49}:\\
\;\;\;\;\frac{x \cdot \frac{{a}^{\left(t + -1\right)}}{e^{b}}}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -6.5e6 or 3.7999999999999999e49 < y Initial program 100.0%
Taylor expanded in t around 0 93.1%
+-commutative93.1%
mul-1-neg93.1%
unsub-neg93.1%
Simplified93.1%
Taylor expanded in b around 0 82.7%
*-commutative82.7%
div-exp82.7%
*-commutative82.7%
exp-to-pow82.7%
rem-exp-log82.7%
Simplified82.7%
*-commutative82.7%
associate-/l*82.7%
Applied egg-rr82.7%
if -6.5e6 < y < -8.00000000000000053e-68Initial program 98.3%
associate-/l*98.3%
associate--l+98.3%
exp-sum90.6%
associate-/l*90.6%
*-commutative90.6%
exp-to-pow90.6%
exp-diff67.5%
*-commutative67.5%
exp-to-pow69.1%
sub-neg69.1%
metadata-eval69.1%
Simplified69.1%
Taylor expanded in y around 0 67.5%
associate-/r*67.5%
exp-to-pow69.1%
sub-neg69.1%
metadata-eval69.1%
Simplified69.1%
Taylor expanded in t around 0 100.0%
if -8.00000000000000053e-68 < y < 3.7999999999999999e49Initial program 97.2%
Taylor expanded in y around 0 95.4%
div-exp84.5%
exp-to-pow85.8%
sub-neg85.8%
metadata-eval85.8%
Simplified85.8%
Final simplification85.1%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -5.1e+148) (not (<= y 3.6e+105))) (* 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.1e+148) || !(y <= 3.6e+105)) {
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.1d+148)) .or. (.not. (y <= 3.6d+105))) 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.1e+148) || !(y <= 3.6e+105)) {
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.1e+148) or not (y <= 3.6e+105): 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.1e+148) || !(y <= 3.6e+105)) 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.1e+148) || ~((y <= 3.6e+105))) 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.1e+148], N[Not[LessEqual[y, 3.6e+105]], $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.1 \cdot 10^{+148} \lor \neg \left(y \leq 3.6 \cdot 10^{+105}\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.09999999999999985e148 or 3.5999999999999999e105 < y Initial program 100.0%
Taylor expanded in t around 0 100.0%
+-commutative100.0%
mul-1-neg100.0%
unsub-neg100.0%
Simplified100.0%
Taylor expanded in b around 0 89.6%
*-commutative89.6%
div-exp89.6%
*-commutative89.6%
exp-to-pow89.6%
rem-exp-log89.6%
Simplified89.6%
*-commutative89.6%
associate-/l*89.6%
Applied egg-rr89.6%
if -5.09999999999999985e148 < y < 3.5999999999999999e105Initial program 97.9%
Taylor expanded in y around 0 91.2%
Final simplification90.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* a (* y (exp b))))) (t_2 (/ (pow z y) a)))
(if (<= b -1.45e+107)
t_1
(if (<= b -5.5e-122)
(* x (/ (pow a (+ t -1.0)) y))
(if (<= b -3e-202)
(* t_2 (/ x y))
(if (<= b 9.5e+30) (* x (/ t_2 y)) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a * (y * exp(b)));
double t_2 = pow(z, y) / a;
double tmp;
if (b <= -1.45e+107) {
tmp = t_1;
} else if (b <= -5.5e-122) {
tmp = x * (pow(a, (t + -1.0)) / y);
} else if (b <= -3e-202) {
tmp = t_2 * (x / y);
} else if (b <= 9.5e+30) {
tmp = x * (t_2 / y);
} 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 / (a * (y * exp(b)))
t_2 = (z ** y) / a
if (b <= (-1.45d+107)) then
tmp = t_1
else if (b <= (-5.5d-122)) then
tmp = x * ((a ** (t + (-1.0d0))) / y)
else if (b <= (-3d-202)) then
tmp = t_2 * (x / y)
else if (b <= 9.5d+30) then
tmp = x * (t_2 / y)
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 / (a * (y * Math.exp(b)));
double t_2 = Math.pow(z, y) / a;
double tmp;
if (b <= -1.45e+107) {
tmp = t_1;
} else if (b <= -5.5e-122) {
tmp = x * (Math.pow(a, (t + -1.0)) / y);
} else if (b <= -3e-202) {
tmp = t_2 * (x / y);
} else if (b <= 9.5e+30) {
tmp = x * (t_2 / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a * (y * math.exp(b))) t_2 = math.pow(z, y) / a tmp = 0 if b <= -1.45e+107: tmp = t_1 elif b <= -5.5e-122: tmp = x * (math.pow(a, (t + -1.0)) / y) elif b <= -3e-202: tmp = t_2 * (x / y) elif b <= 9.5e+30: tmp = x * (t_2 / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a * Float64(y * exp(b)))) t_2 = Float64((z ^ y) / a) tmp = 0.0 if (b <= -1.45e+107) tmp = t_1; elseif (b <= -5.5e-122) tmp = Float64(x * Float64((a ^ Float64(t + -1.0)) / y)); elseif (b <= -3e-202) tmp = Float64(t_2 * Float64(x / y)); elseif (b <= 9.5e+30) tmp = Float64(x * Float64(t_2 / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a * (y * exp(b))); t_2 = (z ^ y) / a; tmp = 0.0; if (b <= -1.45e+107) tmp = t_1; elseif (b <= -5.5e-122) tmp = x * ((a ^ (t + -1.0)) / y); elseif (b <= -3e-202) tmp = t_2 * (x / y); elseif (b <= 9.5e+30) tmp = x * (t_2 / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]}, If[LessEqual[b, -1.45e+107], t$95$1, If[LessEqual[b, -5.5e-122], N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -3e-202], N[(t$95$2 * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.5e+30], N[(x * N[(t$95$2 / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
t_2 := \frac{{z}^{y}}{a}\\
\mathbf{if}\;b \leq -1.45 \cdot 10^{+107}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -5.5 \cdot 10^{-122}:\\
\;\;\;\;x \cdot \frac{{a}^{\left(t + -1\right)}}{y}\\
\mathbf{elif}\;b \leq -3 \cdot 10^{-202}:\\
\;\;\;\;t\_2 \cdot \frac{x}{y}\\
\mathbf{elif}\;b \leq 9.5 \cdot 10^{+30}:\\
\;\;\;\;x \cdot \frac{t\_2}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.44999999999999994e107 or 9.5000000000000003e30 < b Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum76.1%
associate-/l*76.1%
*-commutative76.1%
exp-to-pow76.1%
exp-diff58.7%
*-commutative58.7%
exp-to-pow58.7%
sub-neg58.7%
metadata-eval58.7%
Simplified58.7%
Taylor expanded in y around 0 69.6%
associate-/r*66.4%
exp-to-pow66.4%
sub-neg66.4%
metadata-eval66.4%
Simplified66.4%
Taylor expanded in t around 0 86.1%
if -1.44999999999999994e107 < b < -5.50000000000000053e-122Initial program 99.8%
associate-/l*99.8%
associate--l+99.8%
exp-sum76.2%
associate-/l*76.2%
*-commutative76.2%
exp-to-pow76.2%
exp-diff70.3%
*-commutative70.3%
exp-to-pow70.6%
sub-neg70.6%
metadata-eval70.6%
Simplified70.6%
Taylor expanded in y around 0 68.7%
associate-/r*66.7%
exp-to-pow66.9%
sub-neg66.9%
metadata-eval66.9%
Simplified66.9%
Taylor expanded in b around 0 73.1%
Simplified73.3%
if -5.50000000000000053e-122 < b < -3.00000000000000011e-202Initial program 91.6%
Taylor expanded in t around 0 75.3%
+-commutative75.3%
mul-1-neg75.3%
unsub-neg75.3%
Simplified75.3%
Taylor expanded in b around 0 75.3%
div-exp75.2%
*-commutative75.2%
exp-to-pow75.2%
rem-exp-log78.1%
associate-/l*78.1%
associate-/r*72.9%
*-commutative72.9%
times-frac83.3%
Simplified83.3%
if -3.00000000000000011e-202 < b < 9.5000000000000003e30Initial program 97.7%
Taylor expanded in t around 0 84.4%
+-commutative84.4%
mul-1-neg84.4%
unsub-neg84.4%
Simplified84.4%
Taylor expanded in b around 0 83.7%
*-commutative83.7%
div-exp83.7%
*-commutative83.7%
exp-to-pow83.7%
rem-exp-log84.9%
Simplified84.9%
*-commutative84.9%
associate-/l*82.8%
Applied egg-rr82.8%
Final simplification82.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* a (* y (exp b))))) (t_2 (/ (pow z y) a)))
(if (<= b -1.45e+107)
t_1
(if (<= b -1.95e-120)
(* x (/ (pow a (+ t -1.0)) y))
(if (<= b -5e-231)
(* t_2 (/ x y))
(if (<= b 4.9e+33) (/ (* x t_2) y) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a * (y * exp(b)));
double t_2 = pow(z, y) / a;
double tmp;
if (b <= -1.45e+107) {
tmp = t_1;
} else if (b <= -1.95e-120) {
tmp = x * (pow(a, (t + -1.0)) / y);
} else if (b <= -5e-231) {
tmp = t_2 * (x / y);
} else if (b <= 4.9e+33) {
tmp = (x * t_2) / y;
} 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 / (a * (y * exp(b)))
t_2 = (z ** y) / a
if (b <= (-1.45d+107)) then
tmp = t_1
else if (b <= (-1.95d-120)) then
tmp = x * ((a ** (t + (-1.0d0))) / y)
else if (b <= (-5d-231)) then
tmp = t_2 * (x / y)
else if (b <= 4.9d+33) then
tmp = (x * t_2) / y
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 / (a * (y * Math.exp(b)));
double t_2 = Math.pow(z, y) / a;
double tmp;
if (b <= -1.45e+107) {
tmp = t_1;
} else if (b <= -1.95e-120) {
tmp = x * (Math.pow(a, (t + -1.0)) / y);
} else if (b <= -5e-231) {
tmp = t_2 * (x / y);
} else if (b <= 4.9e+33) {
tmp = (x * t_2) / y;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a * (y * math.exp(b))) t_2 = math.pow(z, y) / a tmp = 0 if b <= -1.45e+107: tmp = t_1 elif b <= -1.95e-120: tmp = x * (math.pow(a, (t + -1.0)) / y) elif b <= -5e-231: tmp = t_2 * (x / y) elif b <= 4.9e+33: tmp = (x * t_2) / y else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a * Float64(y * exp(b)))) t_2 = Float64((z ^ y) / a) tmp = 0.0 if (b <= -1.45e+107) tmp = t_1; elseif (b <= -1.95e-120) tmp = Float64(x * Float64((a ^ Float64(t + -1.0)) / y)); elseif (b <= -5e-231) tmp = Float64(t_2 * Float64(x / y)); elseif (b <= 4.9e+33) tmp = Float64(Float64(x * t_2) / y); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a * (y * exp(b))); t_2 = (z ^ y) / a; tmp = 0.0; if (b <= -1.45e+107) tmp = t_1; elseif (b <= -1.95e-120) tmp = x * ((a ^ (t + -1.0)) / y); elseif (b <= -5e-231) tmp = t_2 * (x / y); elseif (b <= 4.9e+33) tmp = (x * t_2) / y; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]}, If[LessEqual[b, -1.45e+107], t$95$1, If[LessEqual[b, -1.95e-120], N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -5e-231], N[(t$95$2 * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.9e+33], N[(N[(x * t$95$2), $MachinePrecision] / y), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
t_2 := \frac{{z}^{y}}{a}\\
\mathbf{if}\;b \leq -1.45 \cdot 10^{+107}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.95 \cdot 10^{-120}:\\
\;\;\;\;x \cdot \frac{{a}^{\left(t + -1\right)}}{y}\\
\mathbf{elif}\;b \leq -5 \cdot 10^{-231}:\\
\;\;\;\;t\_2 \cdot \frac{x}{y}\\
\mathbf{elif}\;b \leq 4.9 \cdot 10^{+33}:\\
\;\;\;\;\frac{x \cdot t\_2}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.44999999999999994e107 or 4.90000000000000014e33 < b Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum76.1%
associate-/l*76.1%
*-commutative76.1%
exp-to-pow76.1%
exp-diff58.7%
*-commutative58.7%
exp-to-pow58.7%
sub-neg58.7%
metadata-eval58.7%
Simplified58.7%
Taylor expanded in y around 0 69.6%
associate-/r*66.4%
exp-to-pow66.4%
sub-neg66.4%
metadata-eval66.4%
Simplified66.4%
Taylor expanded in t around 0 86.1%
if -1.44999999999999994e107 < b < -1.9500000000000001e-120Initial program 99.8%
associate-/l*99.8%
associate--l+99.8%
exp-sum76.2%
associate-/l*76.2%
*-commutative76.2%
exp-to-pow76.2%
exp-diff70.3%
*-commutative70.3%
exp-to-pow70.6%
sub-neg70.6%
metadata-eval70.6%
Simplified70.6%
Taylor expanded in y around 0 68.7%
associate-/r*66.7%
exp-to-pow66.9%
sub-neg66.9%
metadata-eval66.9%
Simplified66.9%
Taylor expanded in b around 0 73.1%
Simplified73.3%
if -1.9500000000000001e-120 < b < -5.00000000000000023e-231Initial program 93.2%
Taylor expanded in t around 0 75.3%
+-commutative75.3%
mul-1-neg75.3%
unsub-neg75.3%
Simplified75.3%
Taylor expanded in b around 0 75.3%
div-exp75.2%
*-commutative75.2%
exp-to-pow75.2%
rem-exp-log77.6%
associate-/l*77.6%
associate-/r*73.4%
*-commutative73.4%
times-frac81.9%
Simplified81.9%
if -5.00000000000000023e-231 < b < 4.90000000000000014e33Initial program 97.6%
Taylor expanded in t around 0 84.8%
+-commutative84.8%
mul-1-neg84.8%
unsub-neg84.8%
Simplified84.8%
Taylor expanded in b around 0 84.1%
*-commutative84.1%
div-exp84.1%
*-commutative84.1%
exp-to-pow84.1%
rem-exp-log85.3%
Simplified85.3%
Final simplification82.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -3.5e+99) (not (<= b 7.2e+27))) (/ x (* a (* y (exp b)))) (* x (/ (/ (pow z y) a) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -3.5e+99) || !(b <= 7.2e+27)) {
tmp = x / (a * (y * exp(b)));
} else {
tmp = x * ((pow(z, y) / 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 <= (-3.5d+99)) .or. (.not. (b <= 7.2d+27))) then
tmp = x / (a * (y * exp(b)))
else
tmp = x * (((z ** y) / 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 <= -3.5e+99) || !(b <= 7.2e+27)) {
tmp = x / (a * (y * Math.exp(b)));
} else {
tmp = x * ((Math.pow(z, y) / a) / y);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -3.5e+99) or not (b <= 7.2e+27): tmp = x / (a * (y * math.exp(b))) else: tmp = x * ((math.pow(z, y) / a) / y) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -3.5e+99) || !(b <= 7.2e+27)) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); else tmp = Float64(x * Float64(Float64((z ^ y) / a) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -3.5e+99) || ~((b <= 7.2e+27))) tmp = x / (a * (y * exp(b))); else tmp = x * (((z ^ y) / a) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -3.5e+99], N[Not[LessEqual[b, 7.2e+27]], $MachinePrecision]], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.5 \cdot 10^{+99} \lor \neg \left(b \leq 7.2 \cdot 10^{+27}\right):\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{\frac{{z}^{y}}{a}}{y}\\
\end{array}
\end{array}
if b < -3.4999999999999998e99 or 7.19999999999999966e27 < b Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum76.8%
associate-/l*76.8%
*-commutative76.8%
exp-to-pow76.8%
exp-diff58.9%
*-commutative58.9%
exp-to-pow58.9%
sub-neg58.9%
metadata-eval58.9%
Simplified58.9%
Taylor expanded in y around 0 69.5%
associate-/r*66.4%
exp-to-pow66.4%
sub-neg66.4%
metadata-eval66.4%
Simplified66.4%
Taylor expanded in t around 0 85.5%
if -3.4999999999999998e99 < b < 7.19999999999999966e27Initial program 97.6%
Taylor expanded in t around 0 80.1%
+-commutative80.1%
mul-1-neg80.1%
unsub-neg80.1%
Simplified80.1%
Taylor expanded in b around 0 77.3%
*-commutative77.3%
div-exp77.3%
*-commutative77.3%
exp-to-pow77.3%
rem-exp-log78.4%
Simplified78.4%
*-commutative78.4%
associate-/l*76.6%
Applied egg-rr76.6%
Final simplification79.9%
(FPCore (x y z t a b) :precision binary64 (if (<= t -8.5e+192) (/ (* x (+ (/ 1.0 a) (* b (+ (* 0.5 (/ b a)) (/ -1.0 a))))) y) (/ x (* a (* y (exp b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -8.5e+192) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / 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 (t <= (-8.5d+192)) then
tmp = (x * ((1.0d0 / a) + (b * ((0.5d0 * (b / a)) + ((-1.0d0) / a))))) / 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 (t <= -8.5e+192) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y;
} else {
tmp = x / (a * (y * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -8.5e+192: tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y else: tmp = x / (a * (y * math.exp(b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -8.5e+192) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(0.5 * Float64(b / a)) + Float64(-1.0 / a))))) / 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 (t <= -8.5e+192) tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y; else tmp = x / (a * (y * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -8.5e+192], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(0.5 * N[(b / a), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -8.5 \cdot 10^{+192}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(0.5 \cdot \frac{b}{a} + \frac{-1}{a}\right)\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\end{array}
\end{array}
if t < -8.49999999999999965e192Initial program 100.0%
Taylor expanded in y around 0 100.0%
div-exp58.8%
exp-to-pow58.8%
sub-neg58.8%
metadata-eval58.8%
Simplified58.8%
Taylor expanded in t around 0 48.2%
Taylor expanded in b around 0 19.5%
Taylor expanded in x around 0 65.8%
if -8.49999999999999965e192 < t Initial program 98.4%
associate-/l*97.4%
associate--l+97.4%
exp-sum80.6%
associate-/l*78.1%
*-commutative78.1%
exp-to-pow78.1%
exp-diff71.0%
*-commutative71.0%
exp-to-pow71.6%
sub-neg71.6%
metadata-eval71.6%
Simplified71.6%
Taylor expanded in y around 0 66.2%
associate-/r*64.6%
exp-to-pow65.1%
sub-neg65.1%
metadata-eval65.1%
Simplified65.1%
Taylor expanded in t around 0 62.5%
Final simplification62.7%
(FPCore (x y z t a b) :precision binary64 (if (<= y 1.8e+67) (/ (/ x (* a (exp b))) y) (/ x (* b (* a (+ y (/ y b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= 1.8e+67) {
tmp = (x / (a * exp(b))) / y;
} else {
tmp = x / (b * (a * (y + (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 (y <= 1.8d+67) then
tmp = (x / (a * exp(b))) / y
else
tmp = x / (b * (a * (y + (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 (y <= 1.8e+67) {
tmp = (x / (a * Math.exp(b))) / y;
} else {
tmp = x / (b * (a * (y + (y / b))));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= 1.8e+67: tmp = (x / (a * math.exp(b))) / y else: tmp = x / (b * (a * (y + (y / b)))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= 1.8e+67) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); else tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= 1.8e+67) tmp = (x / (a * exp(b))) / y; else tmp = x / (b * (a * (y + (y / b)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, 1.8e+67], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.8 \cdot 10^{+67}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\end{array}
\end{array}
if y < 1.7999999999999999e67Initial program 98.1%
Taylor expanded in y around 0 86.6%
div-exp73.5%
exp-to-pow74.3%
sub-neg74.3%
metadata-eval74.3%
Simplified74.3%
Taylor expanded in t around 0 69.0%
if 1.7999999999999999e67 < y Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum68.0%
associate-/l*58.0%
*-commutative58.0%
exp-to-pow58.0%
exp-diff52.0%
*-commutative52.0%
exp-to-pow52.0%
sub-neg52.0%
metadata-eval52.0%
Simplified52.0%
Taylor expanded in y around 0 38.9%
associate-/r*38.9%
exp-to-pow38.9%
sub-neg38.9%
metadata-eval38.9%
Simplified38.9%
Taylor expanded in t around 0 36.3%
Taylor expanded in b around 0 36.4%
Taylor expanded in b around inf 33.4%
associate-/l*41.2%
distribute-lft-out43.2%
Simplified43.2%
Final simplification64.0%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.7e-159)
(/ (* x (+ (/ 1.0 a) (* b (+ (* 0.5 (/ b a)) (/ -1.0 a))))) y)
(if (<= b 5.2e-303)
(/ x (* b (* a (+ y (/ y b)))))
(if (<= b 1.4e+97)
(/ (/ x (+ a (* b (+ a (* 0.5 (* a b)))))) y)
(/
x
(*
a
(+
y
(*
b
(+ y (* b (+ (* 0.16666666666666666 (* y b)) (* y 0.5))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.7e-159) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y;
} else if (b <= 5.2e-303) {
tmp = x / (b * (a * (y + (y / b))));
} else if (b <= 1.4e+97) {
tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y;
} else {
tmp = x / (a * (y + (b * (y + (b * ((0.16666666666666666 * (y * b)) + (y * 0.5)))))));
}
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.7d-159)) then
tmp = (x * ((1.0d0 / a) + (b * ((0.5d0 * (b / a)) + ((-1.0d0) / a))))) / y
else if (b <= 5.2d-303) then
tmp = x / (b * (a * (y + (y / b))))
else if (b <= 1.4d+97) then
tmp = (x / (a + (b * (a + (0.5d0 * (a * b)))))) / y
else
tmp = x / (a * (y + (b * (y + (b * ((0.16666666666666666d0 * (y * b)) + (y * 0.5d0)))))))
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.7e-159) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y;
} else if (b <= 5.2e-303) {
tmp = x / (b * (a * (y + (y / b))));
} else if (b <= 1.4e+97) {
tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y;
} else {
tmp = x / (a * (y + (b * (y + (b * ((0.16666666666666666 * (y * b)) + (y * 0.5)))))));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.7e-159: tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y elif b <= 5.2e-303: tmp = x / (b * (a * (y + (y / b)))) elif b <= 1.4e+97: tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y else: tmp = x / (a * (y + (b * (y + (b * ((0.16666666666666666 * (y * b)) + (y * 0.5))))))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.7e-159) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(0.5 * Float64(b / a)) + Float64(-1.0 / a))))) / y); elseif (b <= 5.2e-303) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); elseif (b <= 1.4e+97) tmp = Float64(Float64(x / Float64(a + Float64(b * Float64(a + Float64(0.5 * Float64(a * b)))))) / y); else tmp = Float64(x / Float64(a * Float64(y + Float64(b * Float64(y + Float64(b * Float64(Float64(0.16666666666666666 * Float64(y * b)) + Float64(y * 0.5)))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.7e-159) tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y; elseif (b <= 5.2e-303) tmp = x / (b * (a * (y + (y / b)))); elseif (b <= 1.4e+97) tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y; else tmp = x / (a * (y + (b * (y + (b * ((0.16666666666666666 * (y * b)) + (y * 0.5))))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.7e-159], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(0.5 * N[(b / a), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 5.2e-303], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.4e+97], N[(N[(x / N[(a + N[(b * N[(a + N[(0.5 * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y + N[(b * N[(y + N[(b * N[(N[(0.16666666666666666 * N[(y * b), $MachinePrecision]), $MachinePrecision] + N[(y * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.7 \cdot 10^{-159}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(0.5 \cdot \frac{b}{a} + \frac{-1}{a}\right)\right)}{y}\\
\mathbf{elif}\;b \leq 5.2 \cdot 10^{-303}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{elif}\;b \leq 1.4 \cdot 10^{+97}:\\
\;\;\;\;\frac{\frac{x}{a + b \cdot \left(a + 0.5 \cdot \left(a \cdot b\right)\right)}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y + b \cdot \left(y + b \cdot \left(0.16666666666666666 \cdot \left(y \cdot b\right) + y \cdot 0.5\right)\right)\right)}\\
\end{array}
\end{array}
if b < -2.7e-159Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 44.6%
Taylor expanded in x around 0 60.5%
if -2.7e-159 < b < 5.20000000000000009e-303Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 5.20000000000000009e-303 < b < 1.4e97Initial program 98.5%
Taylor expanded in y around 0 72.0%
div-exp68.3%
exp-to-pow69.7%
sub-neg69.7%
metadata-eval69.7%
Simplified69.7%
Taylor expanded in t around 0 56.7%
Taylor expanded in b around 0 49.9%
if 1.4e97 < b Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum69.2%
associate-/l*69.2%
*-commutative69.2%
exp-to-pow69.2%
exp-diff56.4%
*-commutative56.4%
exp-to-pow56.4%
sub-neg56.4%
metadata-eval56.4%
Simplified56.4%
Taylor expanded in y around 0 69.3%
associate-/r*64.2%
exp-to-pow64.2%
sub-neg64.2%
metadata-eval64.2%
Simplified64.2%
Taylor expanded in t around 0 77.3%
Taylor expanded in b around 0 72.4%
Final simplification57.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* y a))))
(if (<= b -2e-122)
(+ (* b (- (* b (- t_1 (/ (* x b) (* y a)))) t_1)) t_1)
(if (<= b 2.1e-301)
(/ x (* b (* a (+ y (/ y b)))))
(/
(/
x
(+ a (* b (+ a (* b (+ (* 0.16666666666666666 (* a b)) (* a 0.5)))))))
y)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y * a);
double tmp;
if (b <= -2e-122) {
tmp = (b * ((b * (t_1 - ((x * b) / (y * a)))) - t_1)) + t_1;
} else if (b <= 2.1e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / 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) :: t_1
real(8) :: tmp
t_1 = x / (y * a)
if (b <= (-2d-122)) then
tmp = (b * ((b * (t_1 - ((x * b) / (y * a)))) - t_1)) + t_1
else if (b <= 2.1d-301) then
tmp = x / (b * (a * (y + (y / b))))
else
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666d0 * (a * b)) + (a * 0.5d0))))))) / y
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);
double tmp;
if (b <= -2e-122) {
tmp = (b * ((b * (t_1 - ((x * b) / (y * a)))) - t_1)) + t_1;
} else if (b <= 2.1e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (y * a) tmp = 0 if b <= -2e-122: tmp = (b * ((b * (t_1 - ((x * b) / (y * a)))) - t_1)) + t_1 elif b <= 2.1e-301: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y * a)) tmp = 0.0 if (b <= -2e-122) tmp = Float64(Float64(b * Float64(Float64(b * Float64(t_1 - Float64(Float64(x * b) / Float64(y * a)))) - t_1)) + t_1); elseif (b <= 2.1e-301) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(Float64(x / Float64(a + Float64(b * Float64(a + Float64(b * Float64(Float64(0.16666666666666666 * Float64(a * b)) + Float64(a * 0.5))))))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (y * a); tmp = 0.0; if (b <= -2e-122) tmp = (b * ((b * (t_1 - ((x * b) / (y * a)))) - t_1)) + t_1; elseif (b <= 2.1e-301) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2e-122], N[(N[(b * N[(N[(b * N[(t$95$1 - N[(N[(x * b), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[b, 2.1e-301], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(b * N[(a + N[(b * N[(N[(0.16666666666666666 * N[(a * b), $MachinePrecision]), $MachinePrecision] + N[(a * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y \cdot a}\\
\mathbf{if}\;b \leq -2 \cdot 10^{-122}:\\
\;\;\;\;b \cdot \left(b \cdot \left(t\_1 - \frac{x \cdot b}{y \cdot a}\right) - t\_1\right) + t\_1\\
\mathbf{elif}\;b \leq 2.1 \cdot 10^{-301}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + b \cdot \left(a + b \cdot \left(0.16666666666666666 \cdot \left(a \cdot b\right) + a \cdot 0.5\right)\right)}}{y}\\
\end{array}
\end{array}
if b < -2.00000000000000012e-122Initial program 99.9%
associate-/l*99.9%
associate--l+99.9%
exp-sum77.5%
associate-/l*77.5%
*-commutative77.5%
exp-to-pow77.5%
exp-diff63.7%
*-commutative63.7%
exp-to-pow63.8%
sub-neg63.8%
metadata-eval63.8%
Simplified63.8%
Taylor expanded in y around 0 67.1%
associate-/r*66.0%
exp-to-pow66.1%
sub-neg66.1%
metadata-eval66.1%
Simplified66.1%
Taylor expanded in t around 0 72.9%
Taylor expanded in b around 0 20.2%
Taylor expanded in b around 0 61.8%
if -2.00000000000000012e-122 < b < 2.0999999999999999e-301Initial program 94.0%
associate-/l*94.1%
associate--l+94.1%
exp-sum82.2%
associate-/l*77.4%
*-commutative77.4%
exp-to-pow77.4%
exp-diff77.4%
*-commutative77.4%
exp-to-pow78.7%
sub-neg78.7%
metadata-eval78.7%
Simplified78.7%
Taylor expanded in y around 0 60.6%
associate-/r*60.6%
exp-to-pow61.6%
sub-neg61.6%
metadata-eval61.6%
Simplified61.6%
Taylor expanded in t around 0 37.6%
Taylor expanded in b around 0 37.6%
Taylor expanded in b around inf 36.4%
associate-/l*50.2%
distribute-lft-out50.3%
Simplified50.3%
if 2.0999999999999999e-301 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 54.9%
Final simplification56.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.85e-156)
(/ (* x (+ (/ 1.0 a) (* b (+ (* 0.5 (/ b a)) (/ -1.0 a))))) y)
(if (<= b 2.8e-301)
(/ x (* b (* a (+ y (/ y b)))))
(/
(/
x
(+ a (* b (+ a (* b (+ (* 0.16666666666666666 (* a b)) (* a 0.5)))))))
y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.85e-156) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y;
} else if (b <= 2.8e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / 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.85d-156)) then
tmp = (x * ((1.0d0 / a) + (b * ((0.5d0 * (b / a)) + ((-1.0d0) / a))))) / y
else if (b <= 2.8d-301) then
tmp = x / (b * (a * (y + (y / b))))
else
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666d0 * (a * b)) + (a * 0.5d0))))))) / 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.85e-156) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y;
} else if (b <= 2.8e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.85e-156: tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y elif b <= 2.8e-301: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.85e-156) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(0.5 * Float64(b / a)) + Float64(-1.0 / a))))) / y); elseif (b <= 2.8e-301) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(Float64(x / Float64(a + Float64(b * Float64(a + Float64(b * Float64(Float64(0.16666666666666666 * Float64(a * b)) + Float64(a * 0.5))))))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.85e-156) tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y; elseif (b <= 2.8e-301) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.85e-156], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(0.5 * N[(b / a), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2.8e-301], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(b * N[(a + N[(b * N[(N[(0.16666666666666666 * N[(a * b), $MachinePrecision]), $MachinePrecision] + N[(a * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.85 \cdot 10^{-156}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(0.5 \cdot \frac{b}{a} + \frac{-1}{a}\right)\right)}{y}\\
\mathbf{elif}\;b \leq 2.8 \cdot 10^{-301}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + b \cdot \left(a + b \cdot \left(0.16666666666666666 \cdot \left(a \cdot b\right) + a \cdot 0.5\right)\right)}}{y}\\
\end{array}
\end{array}
if b < -2.84999999999999993e-156Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 44.6%
Taylor expanded in x around 0 60.5%
if -2.84999999999999993e-156 < b < 2.8000000000000001e-301Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 2.8000000000000001e-301 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 54.9%
Final simplification56.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.95e-156)
(/ (+ (/ (* b (- (* b (- x (* x 0.5))) x)) a) (/ x a)) y)
(if (<= b 3.1e-302)
(/ x (* b (* a (+ y (/ y b)))))
(/
(/
x
(+ a (* b (+ a (* b (+ (* 0.16666666666666666 (* a b)) (* a 0.5)))))))
y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.95e-156) {
tmp = (((b * ((b * (x - (x * 0.5))) - x)) / a) + (x / a)) / y;
} else if (b <= 3.1e-302) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / 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.95d-156)) then
tmp = (((b * ((b * (x - (x * 0.5d0))) - x)) / a) + (x / a)) / y
else if (b <= 3.1d-302) then
tmp = x / (b * (a * (y + (y / b))))
else
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666d0 * (a * b)) + (a * 0.5d0))))))) / 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.95e-156) {
tmp = (((b * ((b * (x - (x * 0.5))) - x)) / a) + (x / a)) / y;
} else if (b <= 3.1e-302) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.95e-156: tmp = (((b * ((b * (x - (x * 0.5))) - x)) / a) + (x / a)) / y elif b <= 3.1e-302: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.95e-156) tmp = Float64(Float64(Float64(Float64(b * Float64(Float64(b * Float64(x - Float64(x * 0.5))) - x)) / a) + Float64(x / a)) / y); elseif (b <= 3.1e-302) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(Float64(x / Float64(a + Float64(b * Float64(a + Float64(b * Float64(Float64(0.16666666666666666 * Float64(a * b)) + Float64(a * 0.5))))))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.95e-156) tmp = (((b * ((b * (x - (x * 0.5))) - x)) / a) + (x / a)) / y; elseif (b <= 3.1e-302) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (b * (a + (b * ((0.16666666666666666 * (a * b)) + (a * 0.5))))))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.95e-156], N[(N[(N[(N[(b * N[(N[(b * N[(x - N[(x * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] + N[(x / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 3.1e-302], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(b * N[(a + N[(b * N[(N[(0.16666666666666666 * N[(a * b), $MachinePrecision]), $MachinePrecision] + N[(a * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.95 \cdot 10^{-156}:\\
\;\;\;\;\frac{\frac{b \cdot \left(b \cdot \left(x - x \cdot 0.5\right) - x\right)}{a} + \frac{x}{a}}{y}\\
\mathbf{elif}\;b \leq 3.1 \cdot 10^{-302}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + b \cdot \left(a + b \cdot \left(0.16666666666666666 \cdot \left(a \cdot b\right) + a \cdot 0.5\right)\right)}}{y}\\
\end{array}
\end{array}
if b < -1.9500000000000001e-156Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 44.6%
Taylor expanded in a around 0 60.5%
if -1.9500000000000001e-156 < b < 3.09999999999999983e-302Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 3.09999999999999983e-302 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 54.9%
Final simplification56.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -6.8e-157)
(/ (- (/ x a) (/ (* x b) a)) y)
(if (<= b 2.3e-301)
(/ x (* b (* a (+ y (/ y b)))))
(if (<= b 1.18e+110)
(/ (/ x (+ a (* a b))) y)
(/ x (* a (* y (- 1.0 (* b (- -1.0 (* b 0.5)))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -6.8e-157) {
tmp = ((x / a) - ((x * b) / a)) / y;
} else if (b <= 2.3e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else if (b <= 1.18e+110) {
tmp = (x / (a + (a * b))) / y;
} else {
tmp = x / (a * (y * (1.0 - (b * (-1.0 - (b * 0.5))))));
}
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 <= (-6.8d-157)) then
tmp = ((x / a) - ((x * b) / a)) / y
else if (b <= 2.3d-301) then
tmp = x / (b * (a * (y + (y / b))))
else if (b <= 1.18d+110) then
tmp = (x / (a + (a * b))) / y
else
tmp = x / (a * (y * (1.0d0 - (b * ((-1.0d0) - (b * 0.5d0))))))
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 <= -6.8e-157) {
tmp = ((x / a) - ((x * b) / a)) / y;
} else if (b <= 2.3e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else if (b <= 1.18e+110) {
tmp = (x / (a + (a * b))) / y;
} else {
tmp = x / (a * (y * (1.0 - (b * (-1.0 - (b * 0.5))))));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -6.8e-157: tmp = ((x / a) - ((x * b) / a)) / y elif b <= 2.3e-301: tmp = x / (b * (a * (y + (y / b)))) elif b <= 1.18e+110: tmp = (x / (a + (a * b))) / y else: tmp = x / (a * (y * (1.0 - (b * (-1.0 - (b * 0.5)))))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -6.8e-157) tmp = Float64(Float64(Float64(x / a) - Float64(Float64(x * b) / a)) / y); elseif (b <= 2.3e-301) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); elseif (b <= 1.18e+110) tmp = Float64(Float64(x / Float64(a + Float64(a * b))) / y); else tmp = Float64(x / Float64(a * Float64(y * Float64(1.0 - Float64(b * Float64(-1.0 - Float64(b * 0.5))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -6.8e-157) tmp = ((x / a) - ((x * b) / a)) / y; elseif (b <= 2.3e-301) tmp = x / (b * (a * (y + (y / b)))); elseif (b <= 1.18e+110) tmp = (x / (a + (a * b))) / y; else tmp = x / (a * (y * (1.0 - (b * (-1.0 - (b * 0.5)))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -6.8e-157], N[(N[(N[(x / a), $MachinePrecision] - N[(N[(x * b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2.3e-301], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.18e+110], N[(N[(x / N[(a + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * N[(1.0 - N[(b * N[(-1.0 - N[(b * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6.8 \cdot 10^{-157}:\\
\;\;\;\;\frac{\frac{x}{a} - \frac{x \cdot b}{a}}{y}\\
\mathbf{elif}\;b \leq 2.3 \cdot 10^{-301}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{elif}\;b \leq 1.18 \cdot 10^{+110}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot \left(1 - b \cdot \left(-1 - b \cdot 0.5\right)\right)\right)}\\
\end{array}
\end{array}
if b < -6.79999999999999955e-157Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 51.1%
if -6.79999999999999955e-157 < b < 2.3000000000000002e-301Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 2.3000000000000002e-301 < b < 1.1799999999999999e110Initial program 98.6%
Taylor expanded in y around 0 73.0%
div-exp68.2%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 57.1%
Taylor expanded in b around 0 49.4%
if 1.1799999999999999e110 < b Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum69.4%
associate-/l*69.4%
*-commutative69.4%
exp-to-pow69.4%
exp-diff55.6%
*-commutative55.6%
exp-to-pow55.6%
sub-neg55.6%
metadata-eval55.6%
Simplified55.6%
Taylor expanded in y around 0 69.5%
associate-/r*64.0%
exp-to-pow64.0%
sub-neg64.0%
metadata-eval64.0%
Simplified64.0%
Taylor expanded in t around 0 78.1%
Taylor expanded in b around 0 68.0%
associate-*r*68.0%
Simplified68.0%
Taylor expanded in y around 0 70.5%
Final simplification53.3%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -4.7e-157)
(/ (- (/ x a) (/ (* x b) a)) y)
(if (<= b 2.1e-301)
(/ x (* b (* a (+ y (/ y b)))))
(/ (/ x (+ a (* b (+ a (* 0.5 (* a b)))))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -4.7e-157) {
tmp = ((x / a) - ((x * b) / a)) / y;
} else if (b <= 2.1e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (0.5 * (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 <= (-4.7d-157)) then
tmp = ((x / a) - ((x * b) / a)) / y
else if (b <= 2.1d-301) then
tmp = x / (b * (a * (y + (y / b))))
else
tmp = (x / (a + (b * (a + (0.5d0 * (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 <= -4.7e-157) {
tmp = ((x / a) - ((x * b) / a)) / y;
} else if (b <= 2.1e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -4.7e-157: tmp = ((x / a) - ((x * b) / a)) / y elif b <= 2.1e-301: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -4.7e-157) tmp = Float64(Float64(Float64(x / a) - Float64(Float64(x * b) / a)) / y); elseif (b <= 2.1e-301) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(Float64(x / Float64(a + Float64(b * Float64(a + Float64(0.5 * Float64(a * b)))))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -4.7e-157) tmp = ((x / a) - ((x * b) / a)) / y; elseif (b <= 2.1e-301) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -4.7e-157], N[(N[(N[(x / a), $MachinePrecision] - N[(N[(x * b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2.1e-301], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(b * N[(a + N[(0.5 * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4.7 \cdot 10^{-157}:\\
\;\;\;\;\frac{\frac{x}{a} - \frac{x \cdot b}{a}}{y}\\
\mathbf{elif}\;b \leq 2.1 \cdot 10^{-301}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + b \cdot \left(a + 0.5 \cdot \left(a \cdot b\right)\right)}}{y}\\
\end{array}
\end{array}
if b < -4.7000000000000002e-157Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 51.1%
if -4.7000000000000002e-157 < b < 2.0999999999999999e-301Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 2.0999999999999999e-301 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 53.5%
Final simplification52.2%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -9.6e-150)
(/ (- x (* b (+ x (* b (* x -0.5))))) (* y a))
(if (<= b 9.5e-302)
(/ x (* b (* a (+ y (/ y b)))))
(/ (/ x (+ a (* b (+ a (* 0.5 (* a b)))))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -9.6e-150) {
tmp = (x - (b * (x + (b * (x * -0.5))))) / (y * a);
} else if (b <= 9.5e-302) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (0.5 * (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.6d-150)) then
tmp = (x - (b * (x + (b * (x * (-0.5d0)))))) / (y * a)
else if (b <= 9.5d-302) then
tmp = x / (b * (a * (y + (y / b))))
else
tmp = (x / (a + (b * (a + (0.5d0 * (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.6e-150) {
tmp = (x - (b * (x + (b * (x * -0.5))))) / (y * a);
} else if (b <= 9.5e-302) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -9.6e-150: tmp = (x - (b * (x + (b * (x * -0.5))))) / (y * a) elif b <= 9.5e-302: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -9.6e-150) tmp = Float64(Float64(x - Float64(b * Float64(x + Float64(b * Float64(x * -0.5))))) / Float64(y * a)); elseif (b <= 9.5e-302) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(Float64(x / Float64(a + Float64(b * Float64(a + Float64(0.5 * Float64(a * b)))))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -9.6e-150) tmp = (x - (b * (x + (b * (x * -0.5))))) / (y * a); elseif (b <= 9.5e-302) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -9.6e-150], N[(N[(x - N[(b * N[(x + N[(b * N[(x * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.5e-302], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(b * N[(a + N[(0.5 * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.6 \cdot 10^{-150}:\\
\;\;\;\;\frac{x - b \cdot \left(x + b \cdot \left(x \cdot -0.5\right)\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq 9.5 \cdot 10^{-302}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + b \cdot \left(a + 0.5 \cdot \left(a \cdot b\right)\right)}}{y}\\
\end{array}
\end{array}
if b < -9.6e-150Initial program 99.5%
Taylor expanded in y around 0 85.7%
div-exp66.5%
exp-to-pow67.0%
sub-neg67.0%
metadata-eval67.0%
Simplified67.0%
Taylor expanded in t around 0 71.4%
Taylor expanded in b around 0 44.5%
Taylor expanded in a around 0 58.9%
*-commutative58.9%
associate-*r*58.9%
mul-1-neg58.9%
distribute-rgt-out58.9%
metadata-eval58.9%
Simplified58.9%
if -9.6e-150 < b < 9.49999999999999991e-302Initial program 94.2%
associate-/l*96.4%
associate--l+96.4%
exp-sum85.6%
associate-/l*80.2%
*-commutative80.2%
exp-to-pow80.2%
exp-diff80.2%
*-commutative80.2%
exp-to-pow81.1%
sub-neg81.1%
metadata-eval81.1%
Simplified81.1%
Taylor expanded in y around 0 58.4%
associate-/r*58.4%
exp-to-pow59.0%
sub-neg59.0%
metadata-eval59.0%
Simplified59.0%
Taylor expanded in t around 0 34.3%
Taylor expanded in b around 0 34.3%
Taylor expanded in b around inf 32.9%
associate-/l*48.7%
distribute-lft-out48.7%
Simplified48.7%
if 9.49999999999999991e-302 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 53.5%
Final simplification54.9%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.8e-158)
(/ (* x (+ (/ 1.0 a) (* b (+ (* 0.5 (/ b a)) (/ -1.0 a))))) y)
(if (<= b 2.8e-301)
(/ x (* b (* a (+ y (/ y b)))))
(/ (/ x (+ a (* b (+ a (* 0.5 (* a b)))))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.8e-158) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y;
} else if (b <= 2.8e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (0.5 * (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.8d-158)) then
tmp = (x * ((1.0d0 / a) + (b * ((0.5d0 * (b / a)) + ((-1.0d0) / a))))) / y
else if (b <= 2.8d-301) then
tmp = x / (b * (a * (y + (y / b))))
else
tmp = (x / (a + (b * (a + (0.5d0 * (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.8e-158) {
tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y;
} else if (b <= 2.8e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.8e-158: tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y elif b <= 2.8e-301: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.8e-158) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(0.5 * Float64(b / a)) + Float64(-1.0 / a))))) / y); elseif (b <= 2.8e-301) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(Float64(x / Float64(a + Float64(b * Float64(a + Float64(0.5 * Float64(a * b)))))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -2.8e-158) tmp = (x * ((1.0 / a) + (b * ((0.5 * (b / a)) + (-1.0 / a))))) / y; elseif (b <= 2.8e-301) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (b * (a + (0.5 * (a * b)))))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.8e-158], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(0.5 * N[(b / a), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2.8e-301], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(a + N[(b * N[(a + N[(0.5 * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.8 \cdot 10^{-158}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(0.5 \cdot \frac{b}{a} + \frac{-1}{a}\right)\right)}{y}\\
\mathbf{elif}\;b \leq 2.8 \cdot 10^{-301}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + b \cdot \left(a + 0.5 \cdot \left(a \cdot b\right)\right)}}{y}\\
\end{array}
\end{array}
if b < -2.80000000000000002e-158Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 44.6%
Taylor expanded in x around 0 60.5%
if -2.80000000000000002e-158 < b < 2.8000000000000001e-301Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 2.8000000000000001e-301 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 53.5%
Final simplification55.9%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.2e-150)
(* (/ x (* y a)) (- (- -1.0) b))
(if (<= b 1.15e-302)
(/ x (* b (* a (+ y (/ y b)))))
(/ (/ x (+ a (* a b))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.2e-150) {
tmp = (x / (y * a)) * (-(-1.0) - b);
} else if (b <= 1.15e-302) {
tmp = x / (b * (a * (y + (y / b))));
} 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 <= (-1.2d-150)) then
tmp = (x / (y * a)) * (-(-1.0d0) - b)
else if (b <= 1.15d-302) then
tmp = x / (b * (a * (y + (y / b))))
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 <= -1.2e-150) {
tmp = (x / (y * a)) * (-(-1.0) - b);
} else if (b <= 1.15e-302) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.2e-150: tmp = (x / (y * a)) * (-(-1.0) - b) elif b <= 1.15e-302: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.2e-150) tmp = Float64(Float64(x / Float64(y * a)) * Float64(Float64(-(-1.0)) - b)); elseif (b <= 1.15e-302) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); 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 <= -1.2e-150) tmp = (x / (y * a)) * (-(-1.0) - b); elseif (b <= 1.15e-302) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.2e-150], N[(N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision] * N[((--1.0) - b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.15e-302], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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 -1.2 \cdot 10^{-150}:\\
\;\;\;\;\frac{x}{y \cdot a} \cdot \left(\left(--1\right) - b\right)\\
\mathbf{elif}\;b \leq 1.15 \cdot 10^{-302}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < -1.2e-150Initial program 99.5%
associate-/l*98.7%
associate--l+98.7%
exp-sum76.5%
associate-/l*76.5%
*-commutative76.5%
exp-to-pow76.5%
exp-diff63.4%
*-commutative63.4%
exp-to-pow63.7%
sub-neg63.7%
metadata-eval63.7%
Simplified63.7%
Taylor expanded in y around 0 67.6%
associate-/r*66.6%
exp-to-pow66.9%
sub-neg66.9%
metadata-eval66.9%
Simplified66.9%
Taylor expanded in t around 0 72.4%
Taylor expanded in b around 0 22.4%
Taylor expanded in b around 0 50.1%
mul-1-neg50.1%
remove-double-neg50.1%
distribute-neg-out50.1%
associate-/l*43.4%
mul-1-neg43.4%
distribute-rgt-out43.4%
*-commutative43.4%
Simplified43.4%
if -1.2e-150 < b < 1.15000000000000001e-302Initial program 94.2%
associate-/l*96.4%
associate--l+96.4%
exp-sum85.6%
associate-/l*80.2%
*-commutative80.2%
exp-to-pow80.2%
exp-diff80.2%
*-commutative80.2%
exp-to-pow81.1%
sub-neg81.1%
metadata-eval81.1%
Simplified81.1%
Taylor expanded in y around 0 58.4%
associate-/r*58.4%
exp-to-pow59.0%
sub-neg59.0%
metadata-eval59.0%
Simplified59.0%
Taylor expanded in t around 0 34.3%
Taylor expanded in b around 0 34.3%
Taylor expanded in b around inf 32.9%
associate-/l*48.7%
distribute-lft-out48.7%
Simplified48.7%
if 1.15000000000000001e-302 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 47.6%
Final simplification46.2%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.72e-156)
(/ (- (/ x a) (* b (/ x a))) y)
(if (<= b 6.2e-302)
(/ x (* b (* a (+ y (/ y b)))))
(/ (/ x (+ a (* a b))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.72e-156) {
tmp = ((x / a) - (b * (x / a))) / y;
} else if (b <= 6.2e-302) {
tmp = x / (b * (a * (y + (y / b))));
} 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 <= (-1.72d-156)) then
tmp = ((x / a) - (b * (x / a))) / y
else if (b <= 6.2d-302) then
tmp = x / (b * (a * (y + (y / b))))
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 <= -1.72e-156) {
tmp = ((x / a) - (b * (x / a))) / y;
} else if (b <= 6.2e-302) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.72e-156: tmp = ((x / a) - (b * (x / a))) / y elif b <= 6.2e-302: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.72e-156) tmp = Float64(Float64(Float64(x / a) - Float64(b * Float64(x / a))) / y); elseif (b <= 6.2e-302) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); 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 <= -1.72e-156) tmp = ((x / a) - (b * (x / a))) / y; elseif (b <= 6.2e-302) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.72e-156], N[(N[(N[(x / a), $MachinePrecision] - N[(b * N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 6.2e-302], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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 -1.72 \cdot 10^{-156}:\\
\;\;\;\;\frac{\frac{x}{a} - b \cdot \frac{x}{a}}{y}\\
\mathbf{elif}\;b \leq 6.2 \cdot 10^{-302}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < -1.7199999999999999e-156Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 51.1%
+-commutative51.1%
mul-1-neg51.1%
unsub-neg51.1%
associate-/l*46.3%
Simplified46.3%
if -1.7199999999999999e-156 < b < 6.19999999999999967e-302Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 6.19999999999999967e-302 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 47.6%
Final simplification47.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.1)
(- (/ x (* y a)) (* (/ x a) (/ b y)))
(if (<= b 1.5e-301)
(/ x (* b (* a (+ y (/ y b)))))
(/ (/ x (+ a (* a b))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.1) {
tmp = (x / (y * a)) - ((x / a) * (b / y));
} else if (b <= 1.5e-301) {
tmp = x / (b * (a * (y + (y / b))));
} 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 <= (-1.1d0)) then
tmp = (x / (y * a)) - ((x / a) * (b / y))
else if (b <= 1.5d-301) then
tmp = x / (b * (a * (y + (y / b))))
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 <= -1.1) {
tmp = (x / (y * a)) - ((x / a) * (b / y));
} else if (b <= 1.5e-301) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.1: tmp = (x / (y * a)) - ((x / a) * (b / y)) elif b <= 1.5e-301: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.1) tmp = Float64(Float64(x / Float64(y * a)) - Float64(Float64(x / a) * Float64(b / y))); elseif (b <= 1.5e-301) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); 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 <= -1.1) tmp = (x / (y * a)) - ((x / a) * (b / y)); elseif (b <= 1.5e-301) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.1], N[(N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision] - N[(N[(x / a), $MachinePrecision] * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.5e-301], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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 -1.1:\\
\;\;\;\;\frac{x}{y \cdot a} - \frac{x}{a} \cdot \frac{b}{y}\\
\mathbf{elif}\;b \leq 1.5 \cdot 10^{-301}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < -1.1000000000000001Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum73.5%
associate-/l*73.5%
*-commutative73.5%
exp-to-pow73.5%
exp-diff54.4%
*-commutative54.4%
exp-to-pow54.4%
sub-neg54.4%
metadata-eval54.4%
Simplified54.4%
Taylor expanded in y around 0 63.3%
associate-/r*61.9%
exp-to-pow61.9%
sub-neg61.9%
metadata-eval61.9%
Simplified61.9%
Taylor expanded in t around 0 82.6%
Taylor expanded in b around 0 50.3%
+-commutative50.3%
mul-1-neg50.3%
unsub-neg50.3%
*-commutative50.3%
*-commutative50.3%
times-frac47.5%
Simplified47.5%
if -1.1000000000000001 < b < 1.5e-301Initial program 96.1%
associate-/l*96.2%
associate--l+96.2%
exp-sum84.4%
associate-/l*81.4%
*-commutative81.4%
exp-to-pow81.4%
exp-diff81.4%
*-commutative81.4%
exp-to-pow82.4%
sub-neg82.4%
metadata-eval82.4%
Simplified82.4%
Taylor expanded in y around 0 66.8%
associate-/r*66.8%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 41.4%
Taylor expanded in b around 0 41.4%
Taylor expanded in b around inf 34.7%
associate-/l*44.7%
distribute-lft-out49.2%
Simplified49.2%
if 1.5e-301 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 47.6%
Final simplification48.0%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.4e-156)
(/ (- (/ x a) (/ (* x b) a)) y)
(if (<= b 3.3e-302)
(/ x (* b (* a (+ y (/ y b)))))
(/ (/ x (+ a (* a b))) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.4e-156) {
tmp = ((x / a) - ((x * b) / a)) / y;
} else if (b <= 3.3e-302) {
tmp = x / (b * (a * (y + (y / b))));
} 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.4d-156)) then
tmp = ((x / a) - ((x * b) / a)) / y
else if (b <= 3.3d-302) then
tmp = x / (b * (a * (y + (y / b))))
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.4e-156) {
tmp = ((x / a) - ((x * b) / a)) / y;
} else if (b <= 3.3e-302) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -2.4e-156: tmp = ((x / a) - ((x * b) / a)) / y elif b <= 3.3e-302: tmp = x / (b * (a * (y + (y / b)))) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.4e-156) tmp = Float64(Float64(Float64(x / a) - Float64(Float64(x * b) / a)) / y); elseif (b <= 3.3e-302) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); 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.4e-156) tmp = ((x / a) - ((x * b) / a)) / y; elseif (b <= 3.3e-302) tmp = x / (b * (a * (y + (y / b)))); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.4e-156], N[(N[(N[(x / a), $MachinePrecision] - N[(N[(x * b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 3.3e-302], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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 -2.4 \cdot 10^{-156}:\\
\;\;\;\;\frac{\frac{x}{a} - \frac{x \cdot b}{a}}{y}\\
\mathbf{elif}\;b \leq 3.3 \cdot 10^{-302}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < -2.4e-156Initial program 99.4%
Taylor expanded in y around 0 85.9%
div-exp67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 71.0%
Taylor expanded in b around 0 51.1%
if -2.4e-156 < b < 3.3000000000000002e-302Initial program 94.1%
associate-/l*98.9%
associate--l+98.9%
exp-sum87.5%
associate-/l*81.8%
*-commutative81.8%
exp-to-pow81.8%
exp-diff81.8%
*-commutative81.8%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around 0 58.7%
associate-/r*58.7%
exp-to-pow59.4%
sub-neg59.4%
metadata-eval59.4%
Simplified59.4%
Taylor expanded in t around 0 36.1%
Taylor expanded in b around 0 36.1%
Taylor expanded in b around inf 34.6%
associate-/l*51.3%
distribute-lft-out51.4%
Simplified51.4%
if 3.3000000000000002e-302 < b Initial program 99.0%
Taylor expanded in y around 0 79.4%
div-exp68.6%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 63.4%
Taylor expanded in b around 0 47.6%
Final simplification49.5%
(FPCore (x y z t a b) :precision binary64 (if (<= b 1.55e-296) (* (/ x (* y a)) (- (- -1.0) b)) (/ (/ x (+ a (* a b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= 1.55e-296) {
tmp = (x / (y * a)) * (-(-1.0) - b);
} 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 <= 1.55d-296) then
tmp = (x / (y * a)) * (-(-1.0d0) - b)
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 <= 1.55e-296) {
tmp = (x / (y * a)) * (-(-1.0) - b);
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= 1.55e-296: tmp = (x / (y * a)) * (-(-1.0) - b) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= 1.55e-296) tmp = Float64(Float64(x / Float64(y * a)) * Float64(Float64(-(-1.0)) - b)); 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 <= 1.55e-296) tmp = (x / (y * a)) * (-(-1.0) - b); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, 1.55e-296], N[(N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision] * N[((--1.0) - b), $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 1.55 \cdot 10^{-296}:\\
\;\;\;\;\frac{x}{y \cdot a} \cdot \left(\left(--1\right) - b\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < 1.5500000000000001e-296Initial program 98.1%
associate-/l*98.1%
associate--l+98.1%
exp-sum79.3%
associate-/l*77.8%
*-commutative77.8%
exp-to-pow77.8%
exp-diff68.4%
*-commutative68.4%
exp-to-pow68.9%
sub-neg68.9%
metadata-eval68.9%
Simplified68.9%
Taylor expanded in y around 0 64.9%
associate-/r*64.2%
exp-to-pow64.6%
sub-neg64.6%
metadata-eval64.6%
Simplified64.6%
Taylor expanded in t around 0 61.1%
Taylor expanded in b around 0 25.3%
Taylor expanded in b around 0 45.1%
mul-1-neg45.1%
remove-double-neg45.1%
distribute-neg-out45.1%
associate-/l*40.4%
mul-1-neg40.4%
distribute-rgt-out40.4%
*-commutative40.4%
Simplified40.4%
if 1.5500000000000001e-296 < b Initial program 99.0%
Taylor expanded in y around 0 79.9%
div-exp68.9%
exp-to-pow69.9%
sub-neg69.9%
metadata-eval69.9%
Simplified69.9%
Taylor expanded in t around 0 64.4%
Taylor expanded in b around 0 48.4%
Final simplification44.1%
(FPCore (x y z t a b) :precision binary64 (if (<= b 3.8e-292) (* (/ x y) (/ 1.0 a)) (/ (/ x (+ a (* a b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= 3.8e-292) {
tmp = (x / y) * (1.0 / 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 <= 3.8d-292) then
tmp = (x / y) * (1.0d0 / 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 <= 3.8e-292) {
tmp = (x / y) * (1.0 / a);
} else {
tmp = (x / (a + (a * b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= 3.8e-292: tmp = (x / y) * (1.0 / a) else: tmp = (x / (a + (a * b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= 3.8e-292) tmp = Float64(Float64(x / y) * Float64(1.0 / 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 <= 3.8e-292) tmp = (x / y) * (1.0 / a); else tmp = (x / (a + (a * b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, 3.8e-292], N[(N[(x / y), $MachinePrecision] * N[(1.0 / 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 3.8 \cdot 10^{-292}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a + a \cdot b}}{y}\\
\end{array}
\end{array}
if b < 3.8000000000000002e-292Initial program 98.1%
Taylor expanded in t around 0 81.8%
+-commutative81.8%
mul-1-neg81.8%
unsub-neg81.8%
Simplified81.8%
Taylor expanded in b around 0 57.3%
div-exp57.3%
*-commutative57.3%
exp-to-pow57.3%
rem-exp-log57.8%
associate-/l*57.8%
associate-/r*56.2%
*-commutative56.2%
times-frac56.2%
Simplified56.2%
Taylor expanded in y around 0 35.4%
if 3.8000000000000002e-292 < b Initial program 99.0%
Taylor expanded in y around 0 79.9%
div-exp68.9%
exp-to-pow69.9%
sub-neg69.9%
metadata-eval69.9%
Simplified69.9%
Taylor expanded in t around 0 64.4%
Taylor expanded in b around 0 48.4%
Final simplification41.4%
(FPCore (x y z t a b) :precision binary64 (if (<= b 11500.0) (/ (/ 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 <= 11500.0) {
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 <= 11500.0d0) 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 <= 11500.0) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= 11500.0: 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 <= 11500.0) 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 <= 11500.0) 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, 11500.0], 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 11500:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < 11500Initial program 98.1%
Taylor expanded in t around 0 83.6%
+-commutative83.6%
mul-1-neg83.6%
unsub-neg83.6%
Simplified83.6%
Taylor expanded in b around 0 66.5%
*-commutative66.5%
div-exp66.5%
*-commutative66.5%
exp-to-pow66.5%
rem-exp-log67.4%
Simplified67.4%
Taylor expanded in y around 0 38.7%
associate-/r*40.1%
Simplified40.1%
if 11500 < b Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum74.1%
associate-/l*74.1%
*-commutative74.1%
exp-to-pow74.1%
exp-diff59.3%
*-commutative59.3%
exp-to-pow59.3%
sub-neg59.3%
metadata-eval59.3%
Simplified59.3%
Taylor expanded in y around 0 68.6%
associate-/r*63.1%
exp-to-pow63.1%
sub-neg63.1%
metadata-eval63.1%
Simplified63.1%
Taylor expanded in t around 0 74.5%
Taylor expanded in b around 0 42.7%
Taylor expanded in b around inf 42.7%
*-commutative42.7%
Simplified42.7%
Final simplification40.7%
(FPCore (x y z t a b) :precision binary64 (if (<= a 4e+100) (/ (/ x a) y) (/ x (* y a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 4e+100) {
tmp = (x / a) / y;
} else {
tmp = x / (y * a);
}
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 (a <= 4d+100) then
tmp = (x / a) / y
else
tmp = x / (y * a)
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 (a <= 4e+100) {
tmp = (x / a) / y;
} else {
tmp = x / (y * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 4e+100: tmp = (x / a) / y else: tmp = x / (y * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 4e+100) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(y * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 4e+100) tmp = (x / a) / y; else tmp = x / (y * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 4e+100], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 4 \cdot 10^{+100}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\end{array}
\end{array}
if a < 4.00000000000000006e100Initial program 99.3%
Taylor expanded in t around 0 83.4%
+-commutative83.4%
mul-1-neg83.4%
unsub-neg83.4%
Simplified83.4%
Taylor expanded in b around 0 64.9%
*-commutative64.9%
div-exp64.9%
*-commutative64.9%
exp-to-pow64.9%
rem-exp-log65.6%
Simplified65.6%
Taylor expanded in y around 0 30.9%
associate-/r*34.7%
Simplified34.7%
if 4.00000000000000006e100 < a Initial program 96.6%
Taylor expanded in t around 0 86.5%
+-commutative86.5%
mul-1-neg86.5%
unsub-neg86.5%
Simplified86.5%
Taylor expanded in b around 0 57.0%
*-commutative57.0%
div-exp57.0%
*-commutative57.0%
exp-to-pow57.0%
rem-exp-log57.8%
Simplified57.8%
Taylor expanded in y around 0 44.0%
*-commutative44.0%
Simplified44.0%
Final simplification37.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.5%
Taylor expanded in t around 0 84.4%
+-commutative84.4%
mul-1-neg84.4%
unsub-neg84.4%
Simplified84.4%
Taylor expanded in b around 0 62.5%
*-commutative62.5%
div-exp62.5%
*-commutative62.5%
exp-to-pow62.5%
rem-exp-log63.2%
Simplified63.2%
Taylor expanded in y around 0 34.9%
*-commutative34.9%
Simplified34.9%
Final simplification34.9%
(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 2024067
(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))