
(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 24 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}
\end{array}
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (log a) (+ t -1.0))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + (log(a) * (t + -1.0))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + (log(a) * (t + (-1.0d0)))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + (Math.log(a) * (t + -1.0))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + (math.log(a) * (t + -1.0))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(log(a) * Float64(t + -1.0))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + (log(a) * (t + -1.0))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[Log[a], $MachinePrecision] * N[(t + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \log a \cdot \left(t + -1\right)\right) - b}}{y}
\end{array}
Initial program 98.9%
Final simplification98.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -8.7e+108) (not (<= y 2050000.0))) (/ (* x (exp (- (- (* y (log z)) (log a)) b))) y) (/ (* x (exp (- (* (log a) (+ t -1.0)) b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -8.7e+108) || !(y <= 2050000.0)) {
tmp = (x * exp((((y * log(z)) - log(a)) - b))) / y;
} else {
tmp = (x * exp(((log(a) * (t + -1.0)) - b))) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-8.7d+108)) .or. (.not. (y <= 2050000.0d0))) then
tmp = (x * exp((((y * log(z)) - log(a)) - b))) / y
else
tmp = (x * exp(((log(a) * (t + (-1.0d0))) - b))) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -8.7e+108) || !(y <= 2050000.0)) {
tmp = (x * Math.exp((((y * Math.log(z)) - Math.log(a)) - b))) / y;
} else {
tmp = (x * Math.exp(((Math.log(a) * (t + -1.0)) - b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -8.7e+108) or not (y <= 2050000.0): tmp = (x * math.exp((((y * math.log(z)) - math.log(a)) - b))) / y else: tmp = (x * math.exp(((math.log(a) * (t + -1.0)) - b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -8.7e+108) || !(y <= 2050000.0)) tmp = Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) - log(a)) - b))) / y); else tmp = Float64(Float64(x * exp(Float64(Float64(log(a) * Float64(t + -1.0)) - b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -8.7e+108) || ~((y <= 2050000.0))) tmp = (x * exp((((y * log(z)) - log(a)) - b))) / y; else tmp = (x * exp(((log(a) * (t + -1.0)) - b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -8.7e+108], N[Not[LessEqual[y, 2050000.0]], $MachinePrecision]], N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] - N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * N[Exp[N[(N[(N[Log[a], $MachinePrecision] * N[(t + -1.0), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8.7 \cdot 10^{+108} \lor \neg \left(y \leq 2050000\right):\\
\;\;\;\;\frac{x \cdot e^{\left(y \cdot \log z - \log a\right) - b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\log a \cdot \left(t + -1\right) - b}}{y}\\
\end{array}
\end{array}
if y < -8.6999999999999997e108 or 2.05e6 < y Initial program 100.0%
Taylor expanded in t around 0 94.5%
+-commutative94.5%
mul-1-neg94.5%
unsub-neg94.5%
Simplified94.5%
if -8.6999999999999997e108 < y < 2.05e6Initial program 98.0%
Taylor expanded in y around 0 94.7%
Final simplification94.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (/ x (* a (exp b))) y))
(t_2 (pow a (+ t -1.0)))
(t_3 (* (/ t_2 (exp b)) (/ x y)))
(t_4 (/ (/ (* x (pow z y)) a) y)))
(if (<= y -9e+123)
t_4
(if (<= y -2.3e-60)
t_3
(if (<= y -5e-209)
t_1
(if (<= y 7e-299)
(/ x (/ y t_2))
(if (<= y 2.7e-170) t_1 (if (<= y 0.185) t_3 t_4))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / (a * exp(b))) / y;
double t_2 = pow(a, (t + -1.0));
double t_3 = (t_2 / exp(b)) * (x / y);
double t_4 = ((x * pow(z, y)) / a) / y;
double tmp;
if (y <= -9e+123) {
tmp = t_4;
} else if (y <= -2.3e-60) {
tmp = t_3;
} else if (y <= -5e-209) {
tmp = t_1;
} else if (y <= 7e-299) {
tmp = x / (y / t_2);
} else if (y <= 2.7e-170) {
tmp = t_1;
} else if (y <= 0.185) {
tmp = t_3;
} else {
tmp = t_4;
}
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) :: t_3
real(8) :: t_4
real(8) :: tmp
t_1 = (x / (a * exp(b))) / y
t_2 = a ** (t + (-1.0d0))
t_3 = (t_2 / exp(b)) * (x / y)
t_4 = ((x * (z ** y)) / a) / y
if (y <= (-9d+123)) then
tmp = t_4
else if (y <= (-2.3d-60)) then
tmp = t_3
else if (y <= (-5d-209)) then
tmp = t_1
else if (y <= 7d-299) then
tmp = x / (y / t_2)
else if (y <= 2.7d-170) then
tmp = t_1
else if (y <= 0.185d0) then
tmp = t_3
else
tmp = t_4
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 * Math.exp(b))) / y;
double t_2 = Math.pow(a, (t + -1.0));
double t_3 = (t_2 / Math.exp(b)) * (x / y);
double t_4 = ((x * Math.pow(z, y)) / a) / y;
double tmp;
if (y <= -9e+123) {
tmp = t_4;
} else if (y <= -2.3e-60) {
tmp = t_3;
} else if (y <= -5e-209) {
tmp = t_1;
} else if (y <= 7e-299) {
tmp = x / (y / t_2);
} else if (y <= 2.7e-170) {
tmp = t_1;
} else if (y <= 0.185) {
tmp = t_3;
} else {
tmp = t_4;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x / (a * math.exp(b))) / y t_2 = math.pow(a, (t + -1.0)) t_3 = (t_2 / math.exp(b)) * (x / y) t_4 = ((x * math.pow(z, y)) / a) / y tmp = 0 if y <= -9e+123: tmp = t_4 elif y <= -2.3e-60: tmp = t_3 elif y <= -5e-209: tmp = t_1 elif y <= 7e-299: tmp = x / (y / t_2) elif y <= 2.7e-170: tmp = t_1 elif y <= 0.185: tmp = t_3 else: tmp = t_4 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x / Float64(a * exp(b))) / y) t_2 = a ^ Float64(t + -1.0) t_3 = Float64(Float64(t_2 / exp(b)) * Float64(x / y)) t_4 = Float64(Float64(Float64(x * (z ^ y)) / a) / y) tmp = 0.0 if (y <= -9e+123) tmp = t_4; elseif (y <= -2.3e-60) tmp = t_3; elseif (y <= -5e-209) tmp = t_1; elseif (y <= 7e-299) tmp = Float64(x / Float64(y / t_2)); elseif (y <= 2.7e-170) tmp = t_1; elseif (y <= 0.185) tmp = t_3; else tmp = t_4; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x / (a * exp(b))) / y; t_2 = a ^ (t + -1.0); t_3 = (t_2 / exp(b)) * (x / y); t_4 = ((x * (z ^ y)) / a) / y; tmp = 0.0; if (y <= -9e+123) tmp = t_4; elseif (y <= -2.3e-60) tmp = t_3; elseif (y <= -5e-209) tmp = t_1; elseif (y <= 7e-299) tmp = x / (y / t_2); elseif (y <= 2.7e-170) tmp = t_1; elseif (y <= 0.185) tmp = t_3; else tmp = t_4; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[(t$95$2 / N[Exp[b], $MachinePrecision]), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -9e+123], t$95$4, If[LessEqual[y, -2.3e-60], t$95$3, If[LessEqual[y, -5e-209], t$95$1, If[LessEqual[y, 7e-299], N[(x / N[(y / t$95$2), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.7e-170], t$95$1, If[LessEqual[y, 0.185], t$95$3, t$95$4]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{x}{a \cdot e^{b}}}{y}\\
t_2 := {a}^{\left(t + -1\right)}\\
t_3 := \frac{t_2}{e^{b}} \cdot \frac{x}{y}\\
t_4 := \frac{\frac{x \cdot {z}^{y}}{a}}{y}\\
\mathbf{if}\;y \leq -9 \cdot 10^{+123}:\\
\;\;\;\;t_4\\
\mathbf{elif}\;y \leq -2.3 \cdot 10^{-60}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq -5 \cdot 10^{-209}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 7 \cdot 10^{-299}:\\
\;\;\;\;\frac{x}{\frac{y}{t_2}}\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{-170}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 0.185:\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;t_4\\
\end{array}
\end{array}
if y < -8.99999999999999965e123 or 0.185 < y Initial program 99.9%
Taylor expanded in b around 0 93.4%
exp-sum67.6%
*-commutative67.6%
exp-to-pow67.6%
exp-to-pow67.7%
sub-neg67.7%
metadata-eval67.7%
Simplified67.7%
Taylor expanded in t around 0 85.0%
if -8.99999999999999965e123 < y < -2.3000000000000001e-60 or 2.6999999999999999e-170 < y < 0.185Initial program 99.0%
associate-*l/96.3%
*-commutative96.3%
+-commutative96.3%
associate--l+96.3%
exp-sum84.0%
*-commutative84.0%
exp-to-pow84.8%
sub-neg84.8%
metadata-eval84.8%
exp-diff78.0%
*-commutative78.0%
exp-to-pow78.0%
Simplified78.0%
Taylor expanded in y around 0 82.5%
exp-to-pow83.3%
sub-neg83.3%
metadata-eval83.3%
Simplified83.3%
if -2.3000000000000001e-60 < y < -5.0000000000000005e-209 or 6.99999999999999981e-299 < y < 2.6999999999999999e-170Initial program 98.2%
Taylor expanded in t around 0 88.4%
+-commutative88.4%
mul-1-neg88.4%
unsub-neg88.4%
Simplified88.4%
Taylor expanded in y around 0 88.4%
exp-neg88.4%
associate-*r/88.4%
*-rgt-identity88.4%
+-commutative88.4%
exp-sum88.4%
rem-exp-log90.1%
Simplified90.1%
if -5.0000000000000005e-209 < y < 6.99999999999999981e-299Initial program 94.3%
Taylor expanded in b around 0 78.8%
exp-sum78.8%
*-commutative78.8%
exp-to-pow78.8%
exp-to-pow79.5%
sub-neg79.5%
metadata-eval79.5%
Simplified79.5%
Taylor expanded in y around 0 78.8%
associate-/l*83.4%
exp-to-pow84.5%
sub-neg84.5%
metadata-eval84.5%
+-commutative84.5%
Simplified84.5%
Final simplification85.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (/ (pow z y) (* y (exp b))) (/ x a)))
(t_2 (/ x (/ y (pow a (+ t -1.0))))))
(if (<= t -5.8e+62)
t_2
(if (<= t 1.6e-144)
t_1
(if (<= t 1.75e-7)
(/ (/ (* x (pow z y)) a) y)
(if (<= t 3.4e+27) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (pow(z, y) / (y * exp(b))) * (x / a);
double t_2 = x / (y / pow(a, (t + -1.0)));
double tmp;
if (t <= -5.8e+62) {
tmp = t_2;
} else if (t <= 1.6e-144) {
tmp = t_1;
} else if (t <= 1.75e-7) {
tmp = ((x * pow(z, y)) / a) / y;
} else if (t <= 3.4e+27) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((z ** y) / (y * exp(b))) * (x / a)
t_2 = x / (y / (a ** (t + (-1.0d0))))
if (t <= (-5.8d+62)) then
tmp = t_2
else if (t <= 1.6d-144) then
tmp = t_1
else if (t <= 1.75d-7) then
tmp = ((x * (z ** y)) / a) / y
else if (t <= 3.4d+27) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (Math.pow(z, y) / (y * Math.exp(b))) * (x / a);
double t_2 = x / (y / Math.pow(a, (t + -1.0)));
double tmp;
if (t <= -5.8e+62) {
tmp = t_2;
} else if (t <= 1.6e-144) {
tmp = t_1;
} else if (t <= 1.75e-7) {
tmp = ((x * Math.pow(z, y)) / a) / y;
} else if (t <= 3.4e+27) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (math.pow(z, y) / (y * math.exp(b))) * (x / a) t_2 = x / (y / math.pow(a, (t + -1.0))) tmp = 0 if t <= -5.8e+62: tmp = t_2 elif t <= 1.6e-144: tmp = t_1 elif t <= 1.75e-7: tmp = ((x * math.pow(z, y)) / a) / y elif t <= 3.4e+27: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64((z ^ y) / Float64(y * exp(b))) * Float64(x / a)) t_2 = Float64(x / Float64(y / (a ^ Float64(t + -1.0)))) tmp = 0.0 if (t <= -5.8e+62) tmp = t_2; elseif (t <= 1.6e-144) tmp = t_1; elseif (t <= 1.75e-7) tmp = Float64(Float64(Float64(x * (z ^ y)) / a) / y); elseif (t <= 3.4e+27) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = ((z ^ y) / (y * exp(b))) * (x / a); t_2 = x / (y / (a ^ (t + -1.0))); tmp = 0.0; if (t <= -5.8e+62) tmp = t_2; elseif (t <= 1.6e-144) tmp = t_1; elseif (t <= 1.75e-7) tmp = ((x * (z ^ y)) / a) / y; elseif (t <= 3.4e+27) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[Power[z, y], $MachinePrecision] / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(y / N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.8e+62], t$95$2, If[LessEqual[t, 1.6e-144], t$95$1, If[LessEqual[t, 1.75e-7], N[(N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 3.4e+27], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{{z}^{y}}{y \cdot e^{b}} \cdot \frac{x}{a}\\
t_2 := \frac{x}{\frac{y}{{a}^{\left(t + -1\right)}}}\\
\mathbf{if}\;t \leq -5.8 \cdot 10^{+62}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.6 \cdot 10^{-144}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{-7}:\\
\;\;\;\;\frac{\frac{x \cdot {z}^{y}}{a}}{y}\\
\mathbf{elif}\;t \leq 3.4 \cdot 10^{+27}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -5.79999999999999968e62 or 3.4e27 < t Initial program 100.0%
Taylor expanded in b around 0 85.8%
exp-sum62.3%
*-commutative62.3%
exp-to-pow62.3%
exp-to-pow62.3%
sub-neg62.3%
metadata-eval62.3%
Simplified62.3%
Taylor expanded in y around 0 77.8%
associate-/l*77.8%
exp-to-pow77.8%
sub-neg77.8%
metadata-eval77.8%
+-commutative77.8%
Simplified77.8%
if -5.79999999999999968e62 < t < 1.59999999999999986e-144 or 1.74999999999999992e-7 < t < 3.4e27Initial program 98.0%
associate-*l/91.9%
*-commutative91.9%
+-commutative91.9%
associate--l+91.9%
exp-sum85.6%
*-commutative85.6%
exp-to-pow86.4%
sub-neg86.4%
metadata-eval86.4%
exp-diff79.2%
*-commutative79.2%
exp-to-pow79.2%
Simplified79.2%
Taylor expanded in t around 0 80.7%
times-frac81.5%
Simplified81.5%
if 1.59999999999999986e-144 < t < 1.74999999999999992e-7Initial program 97.8%
Taylor expanded in b around 0 86.4%
exp-sum86.5%
*-commutative86.5%
exp-to-pow86.5%
exp-to-pow88.6%
sub-neg88.6%
metadata-eval88.6%
Simplified88.6%
Taylor expanded in t around 0 88.6%
Final simplification80.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (pow a (+ t -1.0)) (exp b))) (t_2 (/ (/ (* x (pow z y)) a) y)))
(if (<= y -9e+123)
t_2
(if (<= y -4.3e-60)
(* t_1 (/ x y))
(if (<= y -1.4e-204)
(/ (/ x (* a (exp b))) y)
(if (<= y 0.165) (/ (* x t_1) 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)) / exp(b);
double t_2 = ((x * pow(z, y)) / a) / y;
double tmp;
if (y <= -9e+123) {
tmp = t_2;
} else if (y <= -4.3e-60) {
tmp = t_1 * (x / y);
} else if (y <= -1.4e-204) {
tmp = (x / (a * exp(b))) / y;
} else if (y <= 0.165) {
tmp = (x * t_1) / 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))) / exp(b)
t_2 = ((x * (z ** y)) / a) / y
if (y <= (-9d+123)) then
tmp = t_2
else if (y <= (-4.3d-60)) then
tmp = t_1 * (x / y)
else if (y <= (-1.4d-204)) then
tmp = (x / (a * exp(b))) / y
else if (y <= 0.165d0) then
tmp = (x * t_1) / 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)) / Math.exp(b);
double t_2 = ((x * Math.pow(z, y)) / a) / y;
double tmp;
if (y <= -9e+123) {
tmp = t_2;
} else if (y <= -4.3e-60) {
tmp = t_1 * (x / y);
} else if (y <= -1.4e-204) {
tmp = (x / (a * Math.exp(b))) / y;
} else if (y <= 0.165) {
tmp = (x * t_1) / y;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = math.pow(a, (t + -1.0)) / math.exp(b) t_2 = ((x * math.pow(z, y)) / a) / y tmp = 0 if y <= -9e+123: tmp = t_2 elif y <= -4.3e-60: tmp = t_1 * (x / y) elif y <= -1.4e-204: tmp = (x / (a * math.exp(b))) / y elif y <= 0.165: tmp = (x * t_1) / y else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64((a ^ Float64(t + -1.0)) / exp(b)) t_2 = Float64(Float64(Float64(x * (z ^ y)) / a) / y) tmp = 0.0 if (y <= -9e+123) tmp = t_2; elseif (y <= -4.3e-60) tmp = Float64(t_1 * Float64(x / y)); elseif (y <= -1.4e-204) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); elseif (y <= 0.165) tmp = Float64(Float64(x * t_1) / 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)) / exp(b); t_2 = ((x * (z ^ y)) / a) / y; tmp = 0.0; if (y <= -9e+123) tmp = t_2; elseif (y <= -4.3e-60) tmp = t_1 * (x / y); elseif (y <= -1.4e-204) tmp = (x / (a * exp(b))) / y; elseif (y <= 0.165) tmp = (x * t_1) / y; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / N[Exp[b], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -9e+123], t$95$2, If[LessEqual[y, -4.3e-60], N[(t$95$1 * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.4e-204], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[y, 0.165], N[(N[(x * t$95$1), $MachinePrecision] / y), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{{a}^{\left(t + -1\right)}}{e^{b}}\\
t_2 := \frac{\frac{x \cdot {z}^{y}}{a}}{y}\\
\mathbf{if}\;y \leq -9 \cdot 10^{+123}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -4.3 \cdot 10^{-60}:\\
\;\;\;\;t_1 \cdot \frac{x}{y}\\
\mathbf{elif}\;y \leq -1.4 \cdot 10^{-204}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{elif}\;y \leq 0.165:\\
\;\;\;\;\frac{x \cdot t_1}{y}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -8.99999999999999965e123 or 0.165000000000000008 < y Initial program 99.9%
Taylor expanded in b around 0 93.4%
exp-sum67.6%
*-commutative67.6%
exp-to-pow67.6%
exp-to-pow67.7%
sub-neg67.7%
metadata-eval67.7%
Simplified67.7%
Taylor expanded in t around 0 85.0%
if -8.99999999999999965e123 < y < -4.3000000000000001e-60Initial program 100.0%
associate-*l/100.0%
*-commutative100.0%
+-commutative100.0%
associate--l+100.0%
exp-sum84.2%
*-commutative84.2%
exp-to-pow84.2%
sub-neg84.2%
metadata-eval84.2%
exp-diff71.1%
*-commutative71.1%
exp-to-pow71.1%
Simplified71.1%
Taylor expanded in y around 0 82.1%
exp-to-pow82.1%
sub-neg82.1%
metadata-eval82.1%
Simplified82.1%
if -4.3000000000000001e-60 < y < -1.4e-204Initial program 98.1%
Taylor expanded in t around 0 88.8%
+-commutative88.8%
mul-1-neg88.8%
unsub-neg88.8%
Simplified88.8%
Taylor expanded in y around 0 88.8%
exp-neg88.8%
associate-*r/88.8%
*-rgt-identity88.8%
+-commutative88.8%
exp-sum88.8%
rem-exp-log90.7%
Simplified90.7%
if -1.4e-204 < y < 0.165000000000000008Initial program 97.3%
Taylor expanded in y around 0 97.0%
div-exp86.0%
exp-to-pow87.3%
sub-neg87.3%
metadata-eval87.3%
Simplified87.3%
Final simplification86.0%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -5.6e+126) (not (<= y 0.185))) (/ (/ (* x (pow z y)) a) y) (/ (* x (exp (- (* (log a) (+ t -1.0)) b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -5.6e+126) || !(y <= 0.185)) {
tmp = ((x * pow(z, y)) / a) / y;
} else {
tmp = (x * exp(((log(a) * (t + -1.0)) - b))) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-5.6d+126)) .or. (.not. (y <= 0.185d0))) then
tmp = ((x * (z ** y)) / a) / y
else
tmp = (x * exp(((log(a) * (t + (-1.0d0))) - b))) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -5.6e+126) || !(y <= 0.185)) {
tmp = ((x * Math.pow(z, y)) / a) / y;
} else {
tmp = (x * Math.exp(((Math.log(a) * (t + -1.0)) - b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -5.6e+126) or not (y <= 0.185): tmp = ((x * math.pow(z, y)) / a) / y else: tmp = (x * math.exp(((math.log(a) * (t + -1.0)) - b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -5.6e+126) || !(y <= 0.185)) tmp = Float64(Float64(Float64(x * (z ^ y)) / a) / y); else tmp = Float64(Float64(x * exp(Float64(Float64(log(a) * Float64(t + -1.0)) - b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -5.6e+126) || ~((y <= 0.185))) tmp = ((x * (z ^ y)) / a) / y; else tmp = (x * exp(((log(a) * (t + -1.0)) - b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -5.6e+126], N[Not[LessEqual[y, 0.185]], $MachinePrecision]], N[(N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * N[Exp[N[(N[(N[Log[a], $MachinePrecision] * N[(t + -1.0), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.6 \cdot 10^{+126} \lor \neg \left(y \leq 0.185\right):\\
\;\;\;\;\frac{\frac{x \cdot {z}^{y}}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\log a \cdot \left(t + -1\right) - b}}{y}\\
\end{array}
\end{array}
if y < -5.60000000000000018e126 or 0.185 < y Initial program 99.9%
Taylor expanded in b around 0 94.2%
exp-sum68.2%
*-commutative68.2%
exp-to-pow68.3%
exp-to-pow68.3%
sub-neg68.3%
metadata-eval68.3%
Simplified68.3%
Taylor expanded in t around 0 85.8%
if -5.60000000000000018e126 < y < 0.185Initial program 98.1%
Taylor expanded in y around 0 94.2%
Final simplification90.8%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -3.3e+62) (not (<= t 3.3e+27))) (/ x (/ y (pow a (+ t -1.0)))) (/ x (/ a (/ (pow z y) (* y (exp b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -3.3e+62) || !(t <= 3.3e+27)) {
tmp = x / (y / pow(a, (t + -1.0)));
} else {
tmp = x / (a / (pow(z, y) / (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 <= (-3.3d+62)) .or. (.not. (t <= 3.3d+27))) then
tmp = x / (y / (a ** (t + (-1.0d0))))
else
tmp = x / (a / ((z ** y) / (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 <= -3.3e+62) || !(t <= 3.3e+27)) {
tmp = x / (y / Math.pow(a, (t + -1.0)));
} else {
tmp = x / (a / (Math.pow(z, y) / (y * Math.exp(b))));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -3.3e+62) or not (t <= 3.3e+27): tmp = x / (y / math.pow(a, (t + -1.0))) else: tmp = x / (a / (math.pow(z, y) / (y * math.exp(b)))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -3.3e+62) || !(t <= 3.3e+27)) tmp = Float64(x / Float64(y / (a ^ Float64(t + -1.0)))); else tmp = Float64(x / Float64(a / Float64((z ^ y) / Float64(y * exp(b))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -3.3e+62) || ~((t <= 3.3e+27))) tmp = x / (y / (a ^ (t + -1.0))); else tmp = x / (a / ((z ^ y) / (y * exp(b)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -3.3e+62], N[Not[LessEqual[t, 3.3e+27]], $MachinePrecision]], N[(x / N[(y / N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(a / N[(N[Power[z, y], $MachinePrecision] / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.3 \cdot 10^{+62} \lor \neg \left(t \leq 3.3 \cdot 10^{+27}\right):\\
\;\;\;\;\frac{x}{\frac{y}{{a}^{\left(t + -1\right)}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\frac{a}{\frac{{z}^{y}}{y \cdot e^{b}}}}\\
\end{array}
\end{array}
if t < -3.3e62 or 3.2999999999999998e27 < t Initial program 100.0%
Taylor expanded in b around 0 85.8%
exp-sum62.3%
*-commutative62.3%
exp-to-pow62.3%
exp-to-pow62.3%
sub-neg62.3%
metadata-eval62.3%
Simplified62.3%
Taylor expanded in y around 0 77.8%
associate-/l*77.8%
exp-to-pow77.8%
sub-neg77.8%
metadata-eval77.8%
+-commutative77.8%
Simplified77.8%
if -3.3e62 < t < 3.2999999999999998e27Initial program 98.0%
associate-/l*96.9%
associate--l+96.9%
exp-sum83.8%
associate-/r*83.8%
*-commutative83.8%
exp-to-pow83.8%
exp-diff81.7%
*-commutative81.7%
exp-to-pow82.8%
sub-neg82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in t around 0 80.4%
associate-/l*85.2%
Simplified85.2%
Final simplification82.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (/ y (pow a (+ t -1.0))))))
(if (<= t -1.9e+76)
t_1
(if (<= t -7.5e-256)
(/ (/ x (* a (exp b))) y)
(if (<= t 1.4e-7) (* (/ x a) (/ (pow z y) y)) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y / pow(a, (t + -1.0)));
double tmp;
if (t <= -1.9e+76) {
tmp = t_1;
} else if (t <= -7.5e-256) {
tmp = (x / (a * exp(b))) / y;
} else if (t <= 1.4e-7) {
tmp = (x / a) * (pow(z, y) / 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 / (y / (a ** (t + (-1.0d0))))
if (t <= (-1.9d+76)) then
tmp = t_1
else if (t <= (-7.5d-256)) then
tmp = (x / (a * exp(b))) / y
else if (t <= 1.4d-7) then
tmp = (x / a) * ((z ** y) / 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 / (y / Math.pow(a, (t + -1.0)));
double tmp;
if (t <= -1.9e+76) {
tmp = t_1;
} else if (t <= -7.5e-256) {
tmp = (x / (a * Math.exp(b))) / y;
} else if (t <= 1.4e-7) {
tmp = (x / a) * (Math.pow(z, y) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (y / math.pow(a, (t + -1.0))) tmp = 0 if t <= -1.9e+76: tmp = t_1 elif t <= -7.5e-256: tmp = (x / (a * math.exp(b))) / y elif t <= 1.4e-7: tmp = (x / a) * (math.pow(z, y) / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y / (a ^ Float64(t + -1.0)))) tmp = 0.0 if (t <= -1.9e+76) tmp = t_1; elseif (t <= -7.5e-256) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); elseif (t <= 1.4e-7) tmp = Float64(Float64(x / a) * Float64((z ^ y) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (y / (a ^ (t + -1.0))); tmp = 0.0; if (t <= -1.9e+76) tmp = t_1; elseif (t <= -7.5e-256) tmp = (x / (a * exp(b))) / y; elseif (t <= 1.4e-7) tmp = (x / a) * ((z ^ y) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y / N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.9e+76], t$95$1, If[LessEqual[t, -7.5e-256], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 1.4e-7], N[(N[(x / a), $MachinePrecision] * N[(N[Power[z, y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{\frac{y}{{a}^{\left(t + -1\right)}}}\\
\mathbf{if}\;t \leq -1.9 \cdot 10^{+76}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-256}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{-7}:\\
\;\;\;\;\frac{x}{a} \cdot \frac{{z}^{y}}{y}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.90000000000000012e76 or 1.4000000000000001e-7 < t Initial program 99.9%
Taylor expanded in b around 0 87.2%
exp-sum63.9%
*-commutative63.9%
exp-to-pow63.9%
exp-to-pow63.9%
sub-neg63.9%
metadata-eval63.9%
Simplified63.9%
Taylor expanded in y around 0 76.1%
associate-/l*76.1%
exp-to-pow76.2%
sub-neg76.2%
metadata-eval76.2%
+-commutative76.2%
Simplified76.2%
if -1.90000000000000012e76 < t < -7.50000000000000005e-256Initial program 99.0%
Taylor expanded in t around 0 94.0%
+-commutative94.0%
mul-1-neg94.0%
unsub-neg94.0%
Simplified94.0%
Taylor expanded in y around 0 78.5%
exp-neg78.5%
associate-*r/78.5%
*-rgt-identity78.5%
+-commutative78.5%
exp-sum78.5%
rem-exp-log79.4%
Simplified79.4%
if -7.50000000000000005e-256 < t < 1.4000000000000001e-7Initial program 97.3%
associate-*l/93.6%
*-commutative93.6%
+-commutative93.6%
associate--l+93.6%
exp-sum93.7%
*-commutative93.7%
exp-to-pow95.0%
sub-neg95.0%
metadata-eval95.0%
exp-diff87.7%
*-commutative87.7%
exp-to-pow87.8%
Simplified87.8%
Taylor expanded in t around 0 81.9%
times-frac85.3%
Simplified85.3%
Taylor expanded in b around 0 77.5%
Final simplification77.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -1.5e+76)
(/ x (/ y (pow a (+ t -1.0))))
(if (<= t -8.5e-256)
(/ (/ x (* a (exp b))) y)
(if (<= t 1.4e-7)
(* (/ x a) (/ (pow z y) y))
(/ (/ (* x (pow a t)) a) y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.5e+76) {
tmp = x / (y / pow(a, (t + -1.0)));
} else if (t <= -8.5e-256) {
tmp = (x / (a * exp(b))) / y;
} else if (t <= 1.4e-7) {
tmp = (x / a) * (pow(z, y) / y);
} else {
tmp = ((x * pow(a, t)) / a) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-1.5d+76)) then
tmp = x / (y / (a ** (t + (-1.0d0))))
else if (t <= (-8.5d-256)) then
tmp = (x / (a * exp(b))) / y
else if (t <= 1.4d-7) then
tmp = (x / a) * ((z ** y) / y)
else
tmp = ((x * (a ** t)) / a) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.5e+76) {
tmp = x / (y / Math.pow(a, (t + -1.0)));
} else if (t <= -8.5e-256) {
tmp = (x / (a * Math.exp(b))) / y;
} else if (t <= 1.4e-7) {
tmp = (x / a) * (Math.pow(z, y) / y);
} else {
tmp = ((x * Math.pow(a, t)) / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -1.5e+76: tmp = x / (y / math.pow(a, (t + -1.0))) elif t <= -8.5e-256: tmp = (x / (a * math.exp(b))) / y elif t <= 1.4e-7: tmp = (x / a) * (math.pow(z, y) / y) else: tmp = ((x * math.pow(a, t)) / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -1.5e+76) tmp = Float64(x / Float64(y / (a ^ Float64(t + -1.0)))); elseif (t <= -8.5e-256) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); elseif (t <= 1.4e-7) tmp = Float64(Float64(x / a) * Float64((z ^ y) / y)); else tmp = Float64(Float64(Float64(x * (a ^ t)) / a) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -1.5e+76) tmp = x / (y / (a ^ (t + -1.0))); elseif (t <= -8.5e-256) tmp = (x / (a * exp(b))) / y; elseif (t <= 1.4e-7) tmp = (x / a) * ((z ^ y) / y); else tmp = ((x * (a ^ t)) / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.5e+76], N[(x / N[(y / N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -8.5e-256], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 1.4e-7], N[(N[(x / a), $MachinePrecision] * N[(N[Power[z, y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.5 \cdot 10^{+76}:\\
\;\;\;\;\frac{x}{\frac{y}{{a}^{\left(t + -1\right)}}}\\
\mathbf{elif}\;t \leq -8.5 \cdot 10^{-256}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{-7}:\\
\;\;\;\;\frac{x}{a} \cdot \frac{{z}^{y}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x \cdot {a}^{t}}{a}}{y}\\
\end{array}
\end{array}
if t < -1.4999999999999999e76Initial program 100.0%
Taylor expanded in b around 0 90.8%
exp-sum62.9%
*-commutative62.9%
exp-to-pow62.9%
exp-to-pow62.9%
sub-neg62.9%
metadata-eval62.9%
Simplified62.9%
Taylor expanded in y around 0 81.7%
associate-/l*81.7%
exp-to-pow81.7%
sub-neg81.7%
metadata-eval81.7%
+-commutative81.7%
Simplified81.7%
if -1.4999999999999999e76 < t < -8.49999999999999959e-256Initial program 99.0%
Taylor expanded in t around 0 94.0%
+-commutative94.0%
mul-1-neg94.0%
unsub-neg94.0%
Simplified94.0%
Taylor expanded in y around 0 78.5%
exp-neg78.5%
associate-*r/78.5%
*-rgt-identity78.5%
+-commutative78.5%
exp-sum78.5%
rem-exp-log79.4%
Simplified79.4%
if -8.49999999999999959e-256 < t < 1.4000000000000001e-7Initial program 97.3%
associate-*l/93.6%
*-commutative93.6%
+-commutative93.6%
associate--l+93.6%
exp-sum93.7%
*-commutative93.7%
exp-to-pow95.0%
sub-neg95.0%
metadata-eval95.0%
exp-diff87.7%
*-commutative87.7%
exp-to-pow87.8%
Simplified87.8%
Taylor expanded in t around 0 81.9%
times-frac85.3%
Simplified85.3%
Taylor expanded in b around 0 77.5%
if 1.4000000000000001e-7 < t Initial program 99.8%
Taylor expanded in b around 0 85.0%
exp-sum64.4%
*-commutative64.4%
exp-to-pow64.4%
exp-to-pow64.5%
sub-neg64.5%
metadata-eval64.5%
Simplified64.5%
unpow-prod-up64.6%
unpow-164.6%
Applied egg-rr64.6%
associate-*r/64.6%
*-rgt-identity64.6%
Simplified64.6%
Taylor expanded in y around 0 73.0%
Final simplification77.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -4.9e+85)
(/ x (/ y (pow a (+ t -1.0))))
(if (<= t -4.5e-256)
(/ (/ x (* a (exp b))) y)
(if (<= t 1.05e-6)
(/ (/ (* x (pow z y)) a) y)
(/ (/ (* x (pow a t)) a) y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.9e+85) {
tmp = x / (y / pow(a, (t + -1.0)));
} else if (t <= -4.5e-256) {
tmp = (x / (a * exp(b))) / y;
} else if (t <= 1.05e-6) {
tmp = ((x * pow(z, y)) / a) / y;
} else {
tmp = ((x * pow(a, t)) / a) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-4.9d+85)) then
tmp = x / (y / (a ** (t + (-1.0d0))))
else if (t <= (-4.5d-256)) then
tmp = (x / (a * exp(b))) / y
else if (t <= 1.05d-6) then
tmp = ((x * (z ** y)) / a) / y
else
tmp = ((x * (a ** t)) / a) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.9e+85) {
tmp = x / (y / Math.pow(a, (t + -1.0)));
} else if (t <= -4.5e-256) {
tmp = (x / (a * Math.exp(b))) / y;
} else if (t <= 1.05e-6) {
tmp = ((x * Math.pow(z, y)) / a) / y;
} else {
tmp = ((x * Math.pow(a, t)) / a) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -4.9e+85: tmp = x / (y / math.pow(a, (t + -1.0))) elif t <= -4.5e-256: tmp = (x / (a * math.exp(b))) / y elif t <= 1.05e-6: tmp = ((x * math.pow(z, y)) / a) / y else: tmp = ((x * math.pow(a, t)) / a) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4.9e+85) tmp = Float64(x / Float64(y / (a ^ Float64(t + -1.0)))); elseif (t <= -4.5e-256) tmp = Float64(Float64(x / Float64(a * exp(b))) / y); elseif (t <= 1.05e-6) tmp = Float64(Float64(Float64(x * (z ^ y)) / a) / y); else tmp = Float64(Float64(Float64(x * (a ^ t)) / a) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -4.9e+85) tmp = x / (y / (a ^ (t + -1.0))); elseif (t <= -4.5e-256) tmp = (x / (a * exp(b))) / y; elseif (t <= 1.05e-6) tmp = ((x * (z ^ y)) / a) / y; else tmp = ((x * (a ^ t)) / a) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4.9e+85], N[(x / N[(y / N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -4.5e-256], N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 1.05e-6], N[(N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision], N[(N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.9 \cdot 10^{+85}:\\
\;\;\;\;\frac{x}{\frac{y}{{a}^{\left(t + -1\right)}}}\\
\mathbf{elif}\;t \leq -4.5 \cdot 10^{-256}:\\
\;\;\;\;\frac{\frac{x}{a \cdot e^{b}}}{y}\\
\mathbf{elif}\;t \leq 1.05 \cdot 10^{-6}:\\
\;\;\;\;\frac{\frac{x \cdot {z}^{y}}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x \cdot {a}^{t}}{a}}{y}\\
\end{array}
\end{array}
if t < -4.8999999999999997e85Initial program 100.0%
Taylor expanded in b around 0 90.8%
exp-sum62.9%
*-commutative62.9%
exp-to-pow62.9%
exp-to-pow62.9%
sub-neg62.9%
metadata-eval62.9%
Simplified62.9%
Taylor expanded in y around 0 81.7%
associate-/l*81.7%
exp-to-pow81.7%
sub-neg81.7%
metadata-eval81.7%
+-commutative81.7%
Simplified81.7%
if -4.8999999999999997e85 < t < -4.5000000000000003e-256Initial program 99.0%
Taylor expanded in t around 0 94.0%
+-commutative94.0%
mul-1-neg94.0%
unsub-neg94.0%
Simplified94.0%
Taylor expanded in y around 0 78.5%
exp-neg78.5%
associate-*r/78.5%
*-rgt-identity78.5%
+-commutative78.5%
exp-sum78.5%
rem-exp-log79.4%
Simplified79.4%
if -4.5000000000000003e-256 < t < 1.0499999999999999e-6Initial program 97.3%
Taylor expanded in b around 0 81.4%
exp-sum81.4%
*-commutative81.4%
exp-to-pow81.4%
exp-to-pow82.9%
sub-neg82.9%
metadata-eval82.9%
Simplified82.9%
Taylor expanded in t around 0 82.9%
if 1.0499999999999999e-6 < t Initial program 99.8%
Taylor expanded in b around 0 84.6%
exp-sum63.4%
*-commutative63.4%
exp-to-pow63.4%
exp-to-pow63.5%
sub-neg63.5%
metadata-eval63.5%
Simplified63.5%
unpow-prod-up63.6%
unpow-163.6%
Applied egg-rr63.6%
associate-*r/63.6%
*-rgt-identity63.6%
Simplified63.6%
Taylor expanded in y around 0 73.7%
Final simplification79.3%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -40.0) (not (<= b 3.4e+102))) (/ x (* a (* y (exp b)))) (* (/ x a) (/ (pow z y) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -40.0) || !(b <= 3.4e+102)) {
tmp = x / (a * (y * exp(b)));
} else {
tmp = (x / a) * (pow(z, y) / 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 <= (-40.0d0)) .or. (.not. (b <= 3.4d+102))) then
tmp = x / (a * (y * exp(b)))
else
tmp = (x / a) * ((z ** y) / 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 <= -40.0) || !(b <= 3.4e+102)) {
tmp = x / (a * (y * Math.exp(b)));
} else {
tmp = (x / a) * (Math.pow(z, y) / y);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -40.0) or not (b <= 3.4e+102): tmp = x / (a * (y * math.exp(b))) else: tmp = (x / a) * (math.pow(z, y) / y) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -40.0) || !(b <= 3.4e+102)) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); else tmp = Float64(Float64(x / a) * Float64((z ^ y) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -40.0) || ~((b <= 3.4e+102))) tmp = x / (a * (y * exp(b))); else tmp = (x / a) * ((z ^ y) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -40.0], N[Not[LessEqual[b, 3.4e+102]], $MachinePrecision]], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / a), $MachinePrecision] * N[(N[Power[z, y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -40 \lor \neg \left(b \leq 3.4 \cdot 10^{+102}\right):\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a} \cdot \frac{{z}^{y}}{y}\\
\end{array}
\end{array}
if b < -40 or 3.4e102 < b Initial program 100.0%
associate-*l/91.8%
*-commutative91.8%
+-commutative91.8%
associate--l+91.8%
exp-sum72.2%
*-commutative72.2%
exp-to-pow72.2%
sub-neg72.2%
metadata-eval72.2%
exp-diff52.6%
*-commutative52.6%
exp-to-pow52.6%
Simplified52.6%
Taylor expanded in t around 0 70.2%
times-frac65.0%
Simplified65.0%
Taylor expanded in y around 0 86.8%
if -40 < b < 3.4e102Initial program 98.2%
associate-*l/90.1%
*-commutative90.1%
+-commutative90.1%
associate--l+90.1%
exp-sum73.8%
*-commutative73.8%
exp-to-pow74.7%
sub-neg74.7%
metadata-eval74.7%
exp-diff73.5%
*-commutative73.5%
exp-to-pow73.5%
Simplified73.5%
Taylor expanded in t around 0 65.2%
times-frac66.9%
Simplified66.9%
Taylor expanded in b around 0 67.6%
Final simplification74.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= b -1.5e-5) (not (<= b -1.06e-232))) (/ x (* a (* y (exp b)))) (/ (* a (- (* y (/ x y)) (* x b))) (* a (* y a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((b <= -1.5e-5) || !(b <= -1.06e-232)) {
tmp = x / (a * (y * exp(b)));
} else {
tmp = (a * ((y * (x / y)) - (x * b))) / (a * (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 ((b <= (-1.5d-5)) .or. (.not. (b <= (-1.06d-232)))) then
tmp = x / (a * (y * exp(b)))
else
tmp = (a * ((y * (x / y)) - (x * b))) / (a * (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 ((b <= -1.5e-5) || !(b <= -1.06e-232)) {
tmp = x / (a * (y * Math.exp(b)));
} else {
tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (b <= -1.5e-5) or not (b <= -1.06e-232): tmp = x / (a * (y * math.exp(b))) else: tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((b <= -1.5e-5) || !(b <= -1.06e-232)) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); else tmp = Float64(Float64(a * Float64(Float64(y * Float64(x / y)) - Float64(x * b))) / Float64(a * Float64(y * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((b <= -1.5e-5) || ~((b <= -1.06e-232))) tmp = x / (a * (y * exp(b))); else tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -1.5e-5], N[Not[LessEqual[b, -1.06e-232]], $MachinePrecision]], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a * N[(N[(y * N[(x / y), $MachinePrecision]), $MachinePrecision] - N[(x * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.5 \cdot 10^{-5} \lor \neg \left(b \leq -1.06 \cdot 10^{-232}\right):\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{a \cdot \left(y \cdot \frac{x}{y} - x \cdot b\right)}{a \cdot \left(y \cdot a\right)}\\
\end{array}
\end{array}
if b < -1.50000000000000004e-5 or -1.05999999999999994e-232 < b Initial program 98.8%
associate-*l/90.2%
*-commutative90.2%
+-commutative90.2%
associate--l+90.2%
exp-sum73.4%
*-commutative73.4%
exp-to-pow74.0%
sub-neg74.0%
metadata-eval74.0%
exp-diff63.3%
*-commutative63.3%
exp-to-pow63.3%
Simplified63.3%
Taylor expanded in t around 0 68.7%
times-frac67.7%
Simplified67.7%
Taylor expanded in y around 0 65.5%
if -1.50000000000000004e-5 < b < -1.05999999999999994e-232Initial program 99.1%
associate-*l/92.4%
*-commutative92.4%
+-commutative92.4%
associate--l+92.4%
exp-sum72.4%
*-commutative72.4%
exp-to-pow73.1%
sub-neg73.1%
metadata-eval73.1%
exp-diff73.1%
*-commutative73.1%
exp-to-pow73.2%
Simplified73.2%
Taylor expanded in t around 0 61.7%
times-frac61.3%
Simplified61.3%
Taylor expanded in y around 0 32.9%
Taylor expanded in b around 0 32.9%
+-commutative32.9%
associate-/r*34.4%
un-div-inv34.4%
associate-*l/37.6%
associate-*r/37.6%
frac-add38.4%
div-inv38.4%
*-commutative38.4%
neg-mul-138.4%
*-commutative38.4%
distribute-rgt-neg-in38.4%
*-commutative38.4%
Applied egg-rr38.4%
+-commutative38.4%
*-commutative38.4%
associate-*r*48.5%
distribute-rgt-out48.5%
*-commutative48.5%
Simplified48.5%
Final simplification61.5%
(FPCore (x y z t a b) :precision binary64 (/ (/ x (* a (exp b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x / (a * exp(b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x / (a * exp(b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x / (a * Math.exp(b))) / y;
}
def code(x, y, z, t, a, b): return (x / (a * math.exp(b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x / Float64(a * exp(b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x / (a * exp(b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{x}{a \cdot e^{b}}}{y}
\end{array}
Initial program 98.9%
Taylor expanded in t around 0 81.9%
+-commutative81.9%
mul-1-neg81.9%
unsub-neg81.9%
Simplified81.9%
Taylor expanded in y around 0 58.7%
exp-neg58.7%
associate-*r/58.7%
*-rgt-identity58.7%
+-commutative58.7%
exp-sum58.7%
rem-exp-log59.3%
Simplified59.3%
Final simplification59.3%
(FPCore (x y z t a b) :precision binary64 (/ (/ x (* y (exp b))) a))
double code(double x, double y, double z, double t, double a, double b) {
return (x / (y * exp(b))) / 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 * exp(b))) / a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x / (y * Math.exp(b))) / a;
}
def code(x, y, z, t, a, b): return (x / (y * math.exp(b))) / a
function code(x, y, z, t, a, b) return Float64(Float64(x / Float64(y * exp(b))) / a) end
function tmp = code(x, y, z, t, a, b) tmp = (x / (y * exp(b))) / a; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{x}{y \cdot e^{b}}}{a}
\end{array}
Initial program 98.9%
associate-*l/90.7%
*-commutative90.7%
+-commutative90.7%
associate--l+90.7%
exp-sum73.2%
*-commutative73.2%
exp-to-pow73.8%
sub-neg73.8%
metadata-eval73.8%
exp-diff65.6%
*-commutative65.6%
exp-to-pow65.6%
Simplified65.6%
Taylor expanded in t around 0 67.1%
times-frac66.2%
Simplified66.2%
Taylor expanded in y around 0 57.9%
*-un-lft-identity57.9%
times-frac59.7%
Applied egg-rr59.7%
associate-*l/59.7%
*-lft-identity59.7%
Simplified59.7%
Final simplification59.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (/ (- b) y) a))))
(if (<= b -1.55e+69)
t_1
(if (<= b -8e-218)
(/ (/ x y) a)
(if (<= b -1.45e-232)
t_1
(if (<= b 1.7e+37) (/ (/ x a) y) (/ x (* a (* y b)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * ((-b / y) / a);
double tmp;
if (b <= -1.55e+69) {
tmp = t_1;
} else if (b <= -8e-218) {
tmp = (x / y) / a;
} else if (b <= -1.45e-232) {
tmp = t_1;
} else if (b <= 1.7e+37) {
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) :: t_1
real(8) :: tmp
t_1 = x * ((-b / y) / a)
if (b <= (-1.55d+69)) then
tmp = t_1
else if (b <= (-8d-218)) then
tmp = (x / y) / a
else if (b <= (-1.45d-232)) then
tmp = t_1
else if (b <= 1.7d+37) 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 t_1 = x * ((-b / y) / a);
double tmp;
if (b <= -1.55e+69) {
tmp = t_1;
} else if (b <= -8e-218) {
tmp = (x / y) / a;
} else if (b <= -1.45e-232) {
tmp = t_1;
} else if (b <= 1.7e+37) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * ((-b / y) / a) tmp = 0 if b <= -1.55e+69: tmp = t_1 elif b <= -8e-218: tmp = (x / y) / a elif b <= -1.45e-232: tmp = t_1 elif b <= 1.7e+37: tmp = (x / a) / y else: tmp = x / (a * (y * b)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(Float64(Float64(-b) / y) / a)) tmp = 0.0 if (b <= -1.55e+69) tmp = t_1; elseif (b <= -8e-218) tmp = Float64(Float64(x / y) / a); elseif (b <= -1.45e-232) tmp = t_1; elseif (b <= 1.7e+37) 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) t_1 = x * ((-b / y) / a); tmp = 0.0; if (b <= -1.55e+69) tmp = t_1; elseif (b <= -8e-218) tmp = (x / y) / a; elseif (b <= -1.45e-232) tmp = t_1; elseif (b <= 1.7e+37) tmp = (x / a) / y; else tmp = x / (a * (y * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[((-b) / y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.55e+69], t$95$1, If[LessEqual[b, -8e-218], N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -1.45e-232], t$95$1, If[LessEqual[b, 1.7e+37], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{\frac{-b}{y}}{a}\\
\mathbf{if}\;b \leq -1.55 \cdot 10^{+69}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -8 \cdot 10^{-218}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\mathbf{elif}\;b \leq -1.45 \cdot 10^{-232}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 1.7 \cdot 10^{+37}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < -1.5499999999999999e69 or -8.0000000000000003e-218 < b < -1.45e-232Initial program 100.0%
associate-*l/91.2%
*-commutative91.2%
+-commutative91.2%
associate--l+91.2%
exp-sum64.9%
*-commutative64.9%
exp-to-pow64.9%
sub-neg64.9%
metadata-eval64.9%
exp-diff52.6%
*-commutative52.6%
exp-to-pow52.6%
Simplified52.6%
Taylor expanded in t around 0 68.6%
times-frac59.8%
Simplified59.8%
Taylor expanded in y around 0 76.2%
Taylor expanded in b around 0 42.8%
Taylor expanded in b around inf 47.7%
mul-1-neg47.7%
*-commutative47.7%
*-commutative47.7%
associate-*r/47.6%
*-commutative47.6%
distribute-rgt-neg-in47.6%
*-commutative47.6%
associate-/r*51.1%
distribute-neg-frac51.1%
Simplified51.1%
if -1.5499999999999999e69 < b < -8.0000000000000003e-218Initial program 99.2%
associate-*l/90.4%
*-commutative90.4%
+-commutative90.4%
associate--l+90.4%
exp-sum75.7%
*-commutative75.7%
exp-to-pow76.2%
sub-neg76.2%
metadata-eval76.2%
exp-diff71.8%
*-commutative71.8%
exp-to-pow71.9%
Simplified71.9%
Taylor expanded in t around 0 63.2%
times-frac64.4%
Simplified64.4%
Taylor expanded in y around 0 41.9%
*-un-lft-identity41.9%
times-frac50.1%
Applied egg-rr50.1%
associate-*l/50.1%
*-lft-identity50.1%
Simplified50.1%
Taylor expanded in b around 0 43.2%
if -1.45e-232 < b < 1.70000000000000003e37Initial program 97.3%
Taylor expanded in b around 0 97.3%
exp-sum82.3%
*-commutative82.3%
exp-to-pow82.3%
exp-to-pow83.9%
sub-neg83.9%
metadata-eval83.9%
Simplified83.9%
Taylor expanded in t around 0 77.7%
Taylor expanded in y around 0 44.9%
if 1.70000000000000003e37 < b Initial program 100.0%
associate-*l/88.6%
*-commutative88.6%
+-commutative88.6%
associate--l+88.6%
exp-sum70.5%
*-commutative70.5%
exp-to-pow70.5%
sub-neg70.5%
metadata-eval70.5%
exp-diff45.5%
*-commutative45.5%
exp-to-pow45.5%
Simplified45.5%
Taylor expanded in t around 0 65.9%
times-frac63.6%
Simplified63.6%
Taylor expanded in y around 0 86.6%
Taylor expanded in b around 0 55.9%
Taylor expanded in b around inf 55.9%
*-commutative55.9%
Simplified55.9%
Final simplification47.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.55e+69)
(/ (* x (- b)) (* y a))
(if (<= b -7.8e-218)
(/ (/ x y) a)
(if (<= b -2.5e-232)
(* x (/ (/ (- b) y) a))
(if (<= b 4e+32) (/ (/ x a) y) (/ x (* a (* y b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -7.8e-218) {
tmp = (x / y) / a;
} else if (b <= -2.5e-232) {
tmp = x * ((-b / y) / a);
} else if (b <= 4e+32) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.55d+69)) then
tmp = (x * -b) / (y * a)
else if (b <= (-7.8d-218)) then
tmp = (x / y) / a
else if (b <= (-2.5d-232)) then
tmp = x * ((-b / y) / a)
else if (b <= 4d+32) then
tmp = (x / a) / y
else
tmp = x / (a * (y * b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -7.8e-218) {
tmp = (x / y) / a;
} else if (b <= -2.5e-232) {
tmp = x * ((-b / y) / a);
} else if (b <= 4e+32) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.55e+69: tmp = (x * -b) / (y * a) elif b <= -7.8e-218: tmp = (x / y) / a elif b <= -2.5e-232: tmp = x * ((-b / y) / a) elif b <= 4e+32: tmp = (x / a) / y else: tmp = x / (a * (y * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.55e+69) tmp = Float64(Float64(x * Float64(-b)) / Float64(y * a)); elseif (b <= -7.8e-218) tmp = Float64(Float64(x / y) / a); elseif (b <= -2.5e-232) tmp = Float64(x * Float64(Float64(Float64(-b) / y) / a)); elseif (b <= 4e+32) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(a * Float64(y * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.55e+69) tmp = (x * -b) / (y * a); elseif (b <= -7.8e-218) tmp = (x / y) / a; elseif (b <= -2.5e-232) tmp = x * ((-b / y) / a); elseif (b <= 4e+32) tmp = (x / a) / y; else tmp = x / (a * (y * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.55e+69], N[(N[(x * (-b)), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -7.8e-218], N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -2.5e-232], N[(x * N[(N[((-b) / y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4e+32], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.55 \cdot 10^{+69}:\\
\;\;\;\;\frac{x \cdot \left(-b\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq -7.8 \cdot 10^{-218}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\mathbf{elif}\;b \leq -2.5 \cdot 10^{-232}:\\
\;\;\;\;x \cdot \frac{\frac{-b}{y}}{a}\\
\mathbf{elif}\;b \leq 4 \cdot 10^{+32}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < -1.5499999999999999e69Initial program 100.0%
associate-*l/89.8%
*-commutative89.8%
+-commutative89.8%
associate--l+89.8%
exp-sum65.3%
*-commutative65.3%
exp-to-pow65.3%
sub-neg65.3%
metadata-eval65.3%
exp-diff51.0%
*-commutative51.0%
exp-to-pow51.0%
Simplified51.0%
Taylor expanded in t around 0 71.5%
times-frac63.3%
Simplified63.3%
Taylor expanded in y around 0 85.9%
Taylor expanded in b around 0 47.1%
Taylor expanded in b around inf 47.1%
if -1.5499999999999999e69 < b < -7.8e-218Initial program 99.2%
associate-*l/90.4%
*-commutative90.4%
+-commutative90.4%
associate--l+90.4%
exp-sum75.7%
*-commutative75.7%
exp-to-pow76.2%
sub-neg76.2%
metadata-eval76.2%
exp-diff71.8%
*-commutative71.8%
exp-to-pow71.9%
Simplified71.9%
Taylor expanded in t around 0 63.2%
times-frac64.4%
Simplified64.4%
Taylor expanded in y around 0 41.9%
*-un-lft-identity41.9%
times-frac50.1%
Applied egg-rr50.1%
associate-*l/50.1%
*-lft-identity50.1%
Simplified50.1%
Taylor expanded in b around 0 43.2%
if -7.8e-218 < b < -2.5e-232Initial program 100.0%
associate-*l/100.0%
*-commutative100.0%
+-commutative100.0%
associate--l+100.0%
exp-sum62.5%
*-commutative62.5%
exp-to-pow62.5%
sub-neg62.5%
metadata-eval62.5%
exp-diff62.5%
*-commutative62.5%
exp-to-pow62.5%
Simplified62.5%
Taylor expanded in t around 0 51.1%
times-frac38.6%
Simplified38.6%
Taylor expanded in y around 0 16.6%
Taylor expanded in b around 0 16.6%
Taylor expanded in b around inf 51.6%
mul-1-neg51.6%
*-commutative51.6%
*-commutative51.6%
associate-*r/63.3%
*-commutative63.3%
distribute-rgt-neg-in63.3%
*-commutative63.3%
associate-/r*75.4%
distribute-neg-frac75.4%
Simplified75.4%
if -2.5e-232 < b < 4.00000000000000021e32Initial program 97.3%
Taylor expanded in b around 0 97.3%
exp-sum82.3%
*-commutative82.3%
exp-to-pow82.3%
exp-to-pow83.9%
sub-neg83.9%
metadata-eval83.9%
Simplified83.9%
Taylor expanded in t around 0 77.7%
Taylor expanded in y around 0 44.9%
if 4.00000000000000021e32 < b Initial program 100.0%
associate-*l/88.6%
*-commutative88.6%
+-commutative88.6%
associate--l+88.6%
exp-sum70.5%
*-commutative70.5%
exp-to-pow70.5%
sub-neg70.5%
metadata-eval70.5%
exp-diff45.5%
*-commutative45.5%
exp-to-pow45.5%
Simplified45.5%
Taylor expanded in t around 0 65.9%
times-frac63.6%
Simplified63.6%
Taylor expanded in y around 0 86.6%
Taylor expanded in b around 0 55.9%
Taylor expanded in b around inf 55.9%
*-commutative55.9%
Simplified55.9%
Final simplification47.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -9.5e-73)
(/ (- (/ x y) (* x (/ b y))) a)
(if (<= b -2.2e-232)
(/ (* a (- (* y (/ x y)) (* x b))) (* a (* y a)))
(/ 1.0 (* (/ a x) (* y (+ 1.0 b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -9.5e-73) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= -2.2e-232) {
tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a));
} else {
tmp = 1.0 / ((a / x) * (y * (1.0 + 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 <= (-9.5d-73)) then
tmp = ((x / y) - (x * (b / y))) / a
else if (b <= (-2.2d-232)) then
tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a))
else
tmp = 1.0d0 / ((a / x) * (y * (1.0d0 + 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 <= -9.5e-73) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= -2.2e-232) {
tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a));
} else {
tmp = 1.0 / ((a / x) * (y * (1.0 + b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -9.5e-73: tmp = ((x / y) - (x * (b / y))) / a elif b <= -2.2e-232: tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a)) else: tmp = 1.0 / ((a / x) * (y * (1.0 + b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -9.5e-73) tmp = Float64(Float64(Float64(x / y) - Float64(x * Float64(b / y))) / a); elseif (b <= -2.2e-232) tmp = Float64(Float64(a * Float64(Float64(y * Float64(x / y)) - Float64(x * b))) / Float64(a * Float64(y * a))); else tmp = Float64(1.0 / Float64(Float64(a / x) * Float64(y * Float64(1.0 + b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -9.5e-73) tmp = ((x / y) - (x * (b / y))) / a; elseif (b <= -2.2e-232) tmp = (a * ((y * (x / y)) - (x * b))) / (a * (y * a)); else tmp = 1.0 / ((a / x) * (y * (1.0 + b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -9.5e-73], N[(N[(N[(x / y), $MachinePrecision] - N[(x * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -2.2e-232], N[(N[(a * N[(N[(y * N[(x / y), $MachinePrecision]), $MachinePrecision] - N[(x * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(a / x), $MachinePrecision] * N[(y * N[(1.0 + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{-73}:\\
\;\;\;\;\frac{\frac{x}{y} - x \cdot \frac{b}{y}}{a}\\
\mathbf{elif}\;b \leq -2.2 \cdot 10^{-232}:\\
\;\;\;\;\frac{a \cdot \left(y \cdot \frac{x}{y} - x \cdot b\right)}{a \cdot \left(y \cdot a\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{a}{x} \cdot \left(y \cdot \left(1 + b\right)\right)}\\
\end{array}
\end{array}
if b < -9.50000000000000005e-73Initial program 99.5%
associate-*l/91.0%
*-commutative91.0%
+-commutative91.0%
associate--l+91.0%
exp-sum70.3%
*-commutative70.3%
exp-to-pow70.7%
sub-neg70.7%
metadata-eval70.7%
exp-diff58.5%
*-commutative58.5%
exp-to-pow58.5%
Simplified58.5%
Taylor expanded in t around 0 69.0%
times-frac65.2%
Simplified65.2%
Taylor expanded in y around 0 70.6%
*-un-lft-identity70.6%
times-frac74.1%
Applied egg-rr74.1%
associate-*l/74.1%
*-lft-identity74.1%
Simplified74.1%
Taylor expanded in b around 0 46.4%
+-commutative46.4%
mul-1-neg46.4%
unsub-neg46.4%
*-commutative46.4%
associate-*r/45.3%
Simplified45.3%
if -9.50000000000000005e-73 < b < -2.20000000000000002e-232Initial program 99.6%
associate-*l/90.3%
*-commutative90.3%
+-commutative90.3%
associate--l+90.3%
exp-sum71.8%
*-commutative71.8%
exp-to-pow71.9%
sub-neg71.9%
metadata-eval71.9%
exp-diff71.9%
*-commutative71.9%
exp-to-pow72.1%
Simplified72.1%
Taylor expanded in t around 0 59.4%
times-frac56.6%
Simplified56.6%
Taylor expanded in y around 0 32.6%
Taylor expanded in b around 0 32.6%
+-commutative32.6%
associate-/r*34.7%
un-div-inv34.7%
associate-*l/36.9%
associate-*r/36.9%
frac-add40.6%
div-inv40.6%
*-commutative40.6%
neg-mul-140.6%
*-commutative40.6%
distribute-rgt-neg-in40.6%
*-commutative40.6%
Applied egg-rr40.6%
+-commutative40.6%
*-commutative40.6%
associate-*r*52.3%
distribute-rgt-out52.3%
*-commutative52.3%
Simplified52.3%
if -2.20000000000000002e-232 < b Initial program 98.2%
associate-*l/90.7%
*-commutative90.7%
+-commutative90.7%
associate--l+90.7%
exp-sum75.4%
*-commutative75.4%
exp-to-pow76.3%
sub-neg76.3%
metadata-eval76.3%
exp-diff67.9%
*-commutative67.9%
exp-to-pow67.9%
Simplified67.9%
Taylor expanded in t around 0 68.4%
times-frac69.9%
Simplified69.9%
Taylor expanded in y around 0 58.1%
Taylor expanded in b around 0 47.9%
clear-num47.9%
inv-pow47.9%
distribute-lft-out47.9%
associate-/l*47.8%
*-un-lft-identity47.8%
distribute-rgt-out47.8%
Applied egg-rr47.8%
unpow-147.8%
associate-/r/48.6%
+-commutative48.6%
Simplified48.6%
Final simplification48.2%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.55e+69)
(/ (* x (- b)) (* y a))
(if (<= b -1.3e-210)
(/ (/ x y) a)
(if (<= b -2.5e-232)
(* x (/ (/ (- b) y) a))
(* x (/ 1.0 (* a (* y (+ 1.0 b)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -1.3e-210) {
tmp = (x / y) / a;
} else if (b <= -2.5e-232) {
tmp = x * ((-b / y) / a);
} else {
tmp = x * (1.0 / (a * (y * (1.0 + 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 <= (-1.55d+69)) then
tmp = (x * -b) / (y * a)
else if (b <= (-1.3d-210)) then
tmp = (x / y) / a
else if (b <= (-2.5d-232)) then
tmp = x * ((-b / y) / a)
else
tmp = x * (1.0d0 / (a * (y * (1.0d0 + 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 <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -1.3e-210) {
tmp = (x / y) / a;
} else if (b <= -2.5e-232) {
tmp = x * ((-b / y) / a);
} else {
tmp = x * (1.0 / (a * (y * (1.0 + b))));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.55e+69: tmp = (x * -b) / (y * a) elif b <= -1.3e-210: tmp = (x / y) / a elif b <= -2.5e-232: tmp = x * ((-b / y) / a) else: tmp = x * (1.0 / (a * (y * (1.0 + b)))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.55e+69) tmp = Float64(Float64(x * Float64(-b)) / Float64(y * a)); elseif (b <= -1.3e-210) tmp = Float64(Float64(x / y) / a); elseif (b <= -2.5e-232) tmp = Float64(x * Float64(Float64(Float64(-b) / y) / a)); else tmp = Float64(x * Float64(1.0 / Float64(a * Float64(y * Float64(1.0 + b))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.55e+69) tmp = (x * -b) / (y * a); elseif (b <= -1.3e-210) tmp = (x / y) / a; elseif (b <= -2.5e-232) tmp = x * ((-b / y) / a); else tmp = x * (1.0 / (a * (y * (1.0 + b)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.55e+69], N[(N[(x * (-b)), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.3e-210], N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -2.5e-232], N[(x * N[(N[((-b) / y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(x * N[(1.0 / N[(a * N[(y * N[(1.0 + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.55 \cdot 10^{+69}:\\
\;\;\;\;\frac{x \cdot \left(-b\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq -1.3 \cdot 10^{-210}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\mathbf{elif}\;b \leq -2.5 \cdot 10^{-232}:\\
\;\;\;\;x \cdot \frac{\frac{-b}{y}}{a}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{a \cdot \left(y \cdot \left(1 + b\right)\right)}\\
\end{array}
\end{array}
if b < -1.5499999999999999e69Initial program 100.0%
associate-*l/89.8%
*-commutative89.8%
+-commutative89.8%
associate--l+89.8%
exp-sum65.3%
*-commutative65.3%
exp-to-pow65.3%
sub-neg65.3%
metadata-eval65.3%
exp-diff51.0%
*-commutative51.0%
exp-to-pow51.0%
Simplified51.0%
Taylor expanded in t around 0 71.5%
times-frac63.3%
Simplified63.3%
Taylor expanded in y around 0 85.9%
Taylor expanded in b around 0 47.1%
Taylor expanded in b around inf 47.1%
if -1.5499999999999999e69 < b < -1.2999999999999999e-210Initial program 99.2%
associate-*l/90.4%
*-commutative90.4%
+-commutative90.4%
associate--l+90.4%
exp-sum75.7%
*-commutative75.7%
exp-to-pow76.2%
sub-neg76.2%
metadata-eval76.2%
exp-diff71.8%
*-commutative71.8%
exp-to-pow71.9%
Simplified71.9%
Taylor expanded in t around 0 63.2%
times-frac64.4%
Simplified64.4%
Taylor expanded in y around 0 41.9%
*-un-lft-identity41.9%
times-frac50.1%
Applied egg-rr50.1%
associate-*l/50.1%
*-lft-identity50.1%
Simplified50.1%
Taylor expanded in b around 0 43.2%
if -1.2999999999999999e-210 < b < -2.5e-232Initial program 100.0%
associate-*l/100.0%
*-commutative100.0%
+-commutative100.0%
associate--l+100.0%
exp-sum62.5%
*-commutative62.5%
exp-to-pow62.5%
sub-neg62.5%
metadata-eval62.5%
exp-diff62.5%
*-commutative62.5%
exp-to-pow62.5%
Simplified62.5%
Taylor expanded in t around 0 51.1%
times-frac38.6%
Simplified38.6%
Taylor expanded in y around 0 16.6%
Taylor expanded in b around 0 16.6%
Taylor expanded in b around inf 51.6%
mul-1-neg51.6%
*-commutative51.6%
*-commutative51.6%
associate-*r/63.3%
*-commutative63.3%
distribute-rgt-neg-in63.3%
*-commutative63.3%
associate-/r*75.4%
distribute-neg-frac75.4%
Simplified75.4%
if -2.5e-232 < b Initial program 98.2%
associate-*l/90.7%
*-commutative90.7%
+-commutative90.7%
associate--l+90.7%
exp-sum75.4%
*-commutative75.4%
exp-to-pow76.3%
sub-neg76.3%
metadata-eval76.3%
exp-diff67.9%
*-commutative67.9%
exp-to-pow67.9%
Simplified67.9%
Taylor expanded in t around 0 68.4%
times-frac69.9%
Simplified69.9%
Taylor expanded in y around 0 58.1%
Taylor expanded in b around 0 47.9%
clear-num47.9%
associate-/r/48.5%
distribute-lft-out48.5%
*-un-lft-identity48.5%
distribute-rgt-out48.5%
Applied egg-rr48.5%
Final simplification47.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.55e+69)
(/ (* x (- b)) (* y a))
(if (<= b -8e-218)
(/ (/ x y) a)
(if (<= b -2.7e-232)
(* x (/ (/ (- b) y) a))
(/ 1.0 (* (/ a x) (* y (+ 1.0 b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -8e-218) {
tmp = (x / y) / a;
} else if (b <= -2.7e-232) {
tmp = x * ((-b / y) / a);
} else {
tmp = 1.0 / ((a / x) * (y * (1.0 + 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 <= (-1.55d+69)) then
tmp = (x * -b) / (y * a)
else if (b <= (-8d-218)) then
tmp = (x / y) / a
else if (b <= (-2.7d-232)) then
tmp = x * ((-b / y) / a)
else
tmp = 1.0d0 / ((a / x) * (y * (1.0d0 + 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 <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -8e-218) {
tmp = (x / y) / a;
} else if (b <= -2.7e-232) {
tmp = x * ((-b / y) / a);
} else {
tmp = 1.0 / ((a / x) * (y * (1.0 + b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.55e+69: tmp = (x * -b) / (y * a) elif b <= -8e-218: tmp = (x / y) / a elif b <= -2.7e-232: tmp = x * ((-b / y) / a) else: tmp = 1.0 / ((a / x) * (y * (1.0 + b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.55e+69) tmp = Float64(Float64(x * Float64(-b)) / Float64(y * a)); elseif (b <= -8e-218) tmp = Float64(Float64(x / y) / a); elseif (b <= -2.7e-232) tmp = Float64(x * Float64(Float64(Float64(-b) / y) / a)); else tmp = Float64(1.0 / Float64(Float64(a / x) * Float64(y * Float64(1.0 + b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.55e+69) tmp = (x * -b) / (y * a); elseif (b <= -8e-218) tmp = (x / y) / a; elseif (b <= -2.7e-232) tmp = x * ((-b / y) / a); else tmp = 1.0 / ((a / x) * (y * (1.0 + b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.55e+69], N[(N[(x * (-b)), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -8e-218], N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -2.7e-232], N[(x * N[(N[((-b) / y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(a / x), $MachinePrecision] * N[(y * N[(1.0 + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.55 \cdot 10^{+69}:\\
\;\;\;\;\frac{x \cdot \left(-b\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq -8 \cdot 10^{-218}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\mathbf{elif}\;b \leq -2.7 \cdot 10^{-232}:\\
\;\;\;\;x \cdot \frac{\frac{-b}{y}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{a}{x} \cdot \left(y \cdot \left(1 + b\right)\right)}\\
\end{array}
\end{array}
if b < -1.5499999999999999e69Initial program 100.0%
associate-*l/89.8%
*-commutative89.8%
+-commutative89.8%
associate--l+89.8%
exp-sum65.3%
*-commutative65.3%
exp-to-pow65.3%
sub-neg65.3%
metadata-eval65.3%
exp-diff51.0%
*-commutative51.0%
exp-to-pow51.0%
Simplified51.0%
Taylor expanded in t around 0 71.5%
times-frac63.3%
Simplified63.3%
Taylor expanded in y around 0 85.9%
Taylor expanded in b around 0 47.1%
Taylor expanded in b around inf 47.1%
if -1.5499999999999999e69 < b < -8.0000000000000003e-218Initial program 99.2%
associate-*l/90.4%
*-commutative90.4%
+-commutative90.4%
associate--l+90.4%
exp-sum75.7%
*-commutative75.7%
exp-to-pow76.2%
sub-neg76.2%
metadata-eval76.2%
exp-diff71.8%
*-commutative71.8%
exp-to-pow71.9%
Simplified71.9%
Taylor expanded in t around 0 63.2%
times-frac64.4%
Simplified64.4%
Taylor expanded in y around 0 41.9%
*-un-lft-identity41.9%
times-frac50.1%
Applied egg-rr50.1%
associate-*l/50.1%
*-lft-identity50.1%
Simplified50.1%
Taylor expanded in b around 0 43.2%
if -8.0000000000000003e-218 < b < -2.6999999999999999e-232Initial program 100.0%
associate-*l/100.0%
*-commutative100.0%
+-commutative100.0%
associate--l+100.0%
exp-sum62.5%
*-commutative62.5%
exp-to-pow62.5%
sub-neg62.5%
metadata-eval62.5%
exp-diff62.5%
*-commutative62.5%
exp-to-pow62.5%
Simplified62.5%
Taylor expanded in t around 0 51.1%
times-frac38.6%
Simplified38.6%
Taylor expanded in y around 0 16.6%
Taylor expanded in b around 0 16.6%
Taylor expanded in b around inf 51.6%
mul-1-neg51.6%
*-commutative51.6%
*-commutative51.6%
associate-*r/63.3%
*-commutative63.3%
distribute-rgt-neg-in63.3%
*-commutative63.3%
associate-/r*75.4%
distribute-neg-frac75.4%
Simplified75.4%
if -2.6999999999999999e-232 < b Initial program 98.2%
associate-*l/90.7%
*-commutative90.7%
+-commutative90.7%
associate--l+90.7%
exp-sum75.4%
*-commutative75.4%
exp-to-pow76.3%
sub-neg76.3%
metadata-eval76.3%
exp-diff67.9%
*-commutative67.9%
exp-to-pow67.9%
Simplified67.9%
Taylor expanded in t around 0 68.4%
times-frac69.9%
Simplified69.9%
Taylor expanded in y around 0 58.1%
Taylor expanded in b around 0 47.9%
clear-num47.9%
inv-pow47.9%
distribute-lft-out47.9%
associate-/l*47.8%
*-un-lft-identity47.8%
distribute-rgt-out47.8%
Applied egg-rr47.8%
unpow-147.8%
associate-/r/48.6%
+-commutative48.6%
Simplified48.6%
Final simplification47.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.55e+69)
(/ (* x (- b)) (* y a))
(if (<= b -4.3e-212)
(/ (/ x y) a)
(if (<= b -7.8e-233) (* x (/ (/ (- b) y) a)) (/ x (* a (+ y (* y b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -4.3e-212) {
tmp = (x / y) / a;
} else if (b <= -7.8e-233) {
tmp = x * ((-b / y) / a);
} else {
tmp = x / (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 (b <= (-1.55d+69)) then
tmp = (x * -b) / (y * a)
else if (b <= (-4.3d-212)) then
tmp = (x / y) / a
else if (b <= (-7.8d-233)) then
tmp = x * ((-b / y) / a)
else
tmp = x / (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 (b <= -1.55e+69) {
tmp = (x * -b) / (y * a);
} else if (b <= -4.3e-212) {
tmp = (x / y) / a;
} else if (b <= -7.8e-233) {
tmp = x * ((-b / y) / a);
} else {
tmp = x / (a * (y + (y * b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.55e+69: tmp = (x * -b) / (y * a) elif b <= -4.3e-212: tmp = (x / y) / a elif b <= -7.8e-233: tmp = x * ((-b / y) / a) else: tmp = x / (a * (y + (y * b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.55e+69) tmp = Float64(Float64(x * Float64(-b)) / Float64(y * a)); elseif (b <= -4.3e-212) tmp = Float64(Float64(x / y) / a); elseif (b <= -7.8e-233) tmp = Float64(x * Float64(Float64(Float64(-b) / y) / a)); else tmp = Float64(x / 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 (b <= -1.55e+69) tmp = (x * -b) / (y * a); elseif (b <= -4.3e-212) tmp = (x / y) / a; elseif (b <= -7.8e-233) tmp = x * ((-b / y) / a); else tmp = x / (a * (y + (y * b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.55e+69], N[(N[(x * (-b)), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -4.3e-212], N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -7.8e-233], N[(x * N[(N[((-b) / y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(y + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.55 \cdot 10^{+69}:\\
\;\;\;\;\frac{x \cdot \left(-b\right)}{y \cdot a}\\
\mathbf{elif}\;b \leq -4.3 \cdot 10^{-212}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\mathbf{elif}\;b \leq -7.8 \cdot 10^{-233}:\\
\;\;\;\;x \cdot \frac{\frac{-b}{y}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y + y \cdot b\right)}\\
\end{array}
\end{array}
if b < -1.5499999999999999e69Initial program 100.0%
associate-*l/89.8%
*-commutative89.8%
+-commutative89.8%
associate--l+89.8%
exp-sum65.3%
*-commutative65.3%
exp-to-pow65.3%
sub-neg65.3%
metadata-eval65.3%
exp-diff51.0%
*-commutative51.0%
exp-to-pow51.0%
Simplified51.0%
Taylor expanded in t around 0 71.5%
times-frac63.3%
Simplified63.3%
Taylor expanded in y around 0 85.9%
Taylor expanded in b around 0 47.1%
Taylor expanded in b around inf 47.1%
if -1.5499999999999999e69 < b < -4.29999999999999974e-212Initial program 99.2%
associate-*l/90.4%
*-commutative90.4%
+-commutative90.4%
associate--l+90.4%
exp-sum75.7%
*-commutative75.7%
exp-to-pow76.2%
sub-neg76.2%
metadata-eval76.2%
exp-diff71.8%
*-commutative71.8%
exp-to-pow71.9%
Simplified71.9%
Taylor expanded in t around 0 63.2%
times-frac64.4%
Simplified64.4%
Taylor expanded in y around 0 41.9%
*-un-lft-identity41.9%
times-frac50.1%
Applied egg-rr50.1%
associate-*l/50.1%
*-lft-identity50.1%
Simplified50.1%
Taylor expanded in b around 0 43.2%
if -4.29999999999999974e-212 < b < -7.8000000000000002e-233Initial program 100.0%
associate-*l/100.0%
*-commutative100.0%
+-commutative100.0%
associate--l+100.0%
exp-sum62.5%
*-commutative62.5%
exp-to-pow62.5%
sub-neg62.5%
metadata-eval62.5%
exp-diff62.5%
*-commutative62.5%
exp-to-pow62.5%
Simplified62.5%
Taylor expanded in t around 0 51.1%
times-frac38.6%
Simplified38.6%
Taylor expanded in y around 0 16.6%
Taylor expanded in b around 0 16.6%
Taylor expanded in b around inf 51.6%
mul-1-neg51.6%
*-commutative51.6%
*-commutative51.6%
associate-*r/63.3%
*-commutative63.3%
distribute-rgt-neg-in63.3%
*-commutative63.3%
associate-/r*75.4%
distribute-neg-frac75.4%
Simplified75.4%
if -7.8000000000000002e-233 < b Initial program 98.2%
associate-*l/90.7%
*-commutative90.7%
+-commutative90.7%
associate--l+90.7%
exp-sum75.4%
*-commutative75.4%
exp-to-pow76.3%
sub-neg76.3%
metadata-eval76.3%
exp-diff67.9%
*-commutative67.9%
exp-to-pow67.9%
Simplified67.9%
Taylor expanded in t around 0 68.4%
times-frac69.9%
Simplified69.9%
Taylor expanded in y around 0 58.1%
Taylor expanded in b around 0 47.9%
Final simplification47.3%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.35e-214)
(/ (- (/ x y) (* x (/ b y))) a)
(if (<= b -2.4e-232)
(* x (/ (/ (- b) y) a))
(/ 1.0 (* (/ a x) (* y (+ 1.0 b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.35e-214) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= -2.4e-232) {
tmp = x * ((-b / y) / a);
} else {
tmp = 1.0 / ((a / x) * (y * (1.0 + 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 <= (-1.35d-214)) then
tmp = ((x / y) - (x * (b / y))) / a
else if (b <= (-2.4d-232)) then
tmp = x * ((-b / y) / a)
else
tmp = 1.0d0 / ((a / x) * (y * (1.0d0 + 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 <= -1.35e-214) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= -2.4e-232) {
tmp = x * ((-b / y) / a);
} else {
tmp = 1.0 / ((a / x) * (y * (1.0 + b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.35e-214: tmp = ((x / y) - (x * (b / y))) / a elif b <= -2.4e-232: tmp = x * ((-b / y) / a) else: tmp = 1.0 / ((a / x) * (y * (1.0 + b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.35e-214) tmp = Float64(Float64(Float64(x / y) - Float64(x * Float64(b / y))) / a); elseif (b <= -2.4e-232) tmp = Float64(x * Float64(Float64(Float64(-b) / y) / a)); else tmp = Float64(1.0 / Float64(Float64(a / x) * Float64(y * Float64(1.0 + b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.35e-214) tmp = ((x / y) - (x * (b / y))) / a; elseif (b <= -2.4e-232) tmp = x * ((-b / y) / a); else tmp = 1.0 / ((a / x) * (y * (1.0 + b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.35e-214], N[(N[(N[(x / y), $MachinePrecision] - N[(x * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -2.4e-232], N[(x * N[(N[((-b) / y), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(a / x), $MachinePrecision] * N[(y * N[(1.0 + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.35 \cdot 10^{-214}:\\
\;\;\;\;\frac{\frac{x}{y} - x \cdot \frac{b}{y}}{a}\\
\mathbf{elif}\;b \leq -2.4 \cdot 10^{-232}:\\
\;\;\;\;x \cdot \frac{\frac{-b}{y}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{a}{x} \cdot \left(y \cdot \left(1 + b\right)\right)}\\
\end{array}
\end{array}
if b < -1.35e-214Initial program 99.5%
associate-*l/90.1%
*-commutative90.1%
+-commutative90.1%
associate--l+90.1%
exp-sum71.3%
*-commutative71.3%
exp-to-pow71.7%
sub-neg71.7%
metadata-eval71.7%
exp-diff63.1%
*-commutative63.1%
exp-to-pow63.2%
Simplified63.2%
Taylor expanded in t around 0 66.7%
times-frac63.9%
Simplified63.9%
Taylor expanded in y around 0 60.4%
*-un-lft-identity60.4%
times-frac65.1%
Applied egg-rr65.1%
associate-*l/65.1%
*-lft-identity65.1%
Simplified65.1%
Taylor expanded in b around 0 45.7%
+-commutative45.7%
mul-1-neg45.7%
unsub-neg45.7%
*-commutative45.7%
associate-*r/44.9%
Simplified44.9%
if -1.35e-214 < b < -2.39999999999999999e-232Initial program 100.0%
associate-*l/100.0%
*-commutative100.0%
+-commutative100.0%
associate--l+100.0%
exp-sum62.5%
*-commutative62.5%
exp-to-pow62.5%
sub-neg62.5%
metadata-eval62.5%
exp-diff62.5%
*-commutative62.5%
exp-to-pow62.5%
Simplified62.5%
Taylor expanded in t around 0 51.1%
times-frac38.6%
Simplified38.6%
Taylor expanded in y around 0 16.6%
Taylor expanded in b around 0 16.6%
Taylor expanded in b around inf 51.6%
mul-1-neg51.6%
*-commutative51.6%
*-commutative51.6%
associate-*r/63.3%
*-commutative63.3%
distribute-rgt-neg-in63.3%
*-commutative63.3%
associate-/r*75.4%
distribute-neg-frac75.4%
Simplified75.4%
if -2.39999999999999999e-232 < b Initial program 98.2%
associate-*l/90.7%
*-commutative90.7%
+-commutative90.7%
associate--l+90.7%
exp-sum75.4%
*-commutative75.4%
exp-to-pow76.3%
sub-neg76.3%
metadata-eval76.3%
exp-diff67.9%
*-commutative67.9%
exp-to-pow67.9%
Simplified67.9%
Taylor expanded in t around 0 68.4%
times-frac69.9%
Simplified69.9%
Taylor expanded in y around 0 58.1%
Taylor expanded in b around 0 47.9%
clear-num47.9%
inv-pow47.9%
distribute-lft-out47.9%
associate-/l*47.8%
*-un-lft-identity47.8%
distribute-rgt-out47.8%
Applied egg-rr47.8%
unpow-147.8%
associate-/r/48.6%
+-commutative48.6%
Simplified48.6%
Final simplification47.8%
(FPCore (x y z t a b) :precision binary64 (if (<= b 4.8e+31) (/ (/ 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 <= 4.8e+31) {
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 <= 4.8d+31) 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 <= 4.8e+31) {
tmp = (x / a) / y;
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= 4.8e+31: 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 <= 4.8e+31) 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 <= 4.8e+31) 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, 4.8e+31], 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 4.8 \cdot 10^{+31}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < 4.79999999999999965e31Initial program 98.6%
Taylor expanded in b around 0 87.7%
exp-sum74.0%
*-commutative74.0%
exp-to-pow74.0%
exp-to-pow74.8%
sub-neg74.8%
metadata-eval74.8%
Simplified74.8%
Taylor expanded in t around 0 65.5%
Taylor expanded in y around 0 36.1%
if 4.79999999999999965e31 < b Initial program 100.0%
associate-*l/88.6%
*-commutative88.6%
+-commutative88.6%
associate--l+88.6%
exp-sum70.5%
*-commutative70.5%
exp-to-pow70.5%
sub-neg70.5%
metadata-eval70.5%
exp-diff45.5%
*-commutative45.5%
exp-to-pow45.5%
Simplified45.5%
Taylor expanded in t around 0 65.9%
times-frac63.6%
Simplified63.6%
Taylor expanded in y around 0 86.6%
Taylor expanded in b around 0 55.9%
Taylor expanded in b around inf 55.9%
*-commutative55.9%
Simplified55.9%
Final simplification39.5%
(FPCore (x y z t a b) :precision binary64 (/ x (* y a)))
double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / (y * a)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
def code(x, y, z, t, a, b): return x / (y * a)
function code(x, y, z, t, a, b) return Float64(x / Float64(y * a)) end
function tmp = code(x, y, z, t, a, b) tmp = x / (y * a); end
code[x_, y_, z_, t_, a_, b_] := N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y \cdot a}
\end{array}
Initial program 98.9%
associate-*l/90.7%
*-commutative90.7%
+-commutative90.7%
associate--l+90.7%
exp-sum73.2%
*-commutative73.2%
exp-to-pow73.8%
sub-neg73.8%
metadata-eval73.8%
exp-diff65.6%
*-commutative65.6%
exp-to-pow65.6%
Simplified65.6%
Taylor expanded in t around 0 67.1%
times-frac66.2%
Simplified66.2%
Taylor expanded in y around 0 57.9%
Taylor expanded in b around 0 33.1%
Final simplification33.1%
(FPCore (x y z t a b) :precision binary64 (/ (/ x a) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x / a) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x / a) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x / a) / y;
}
def code(x, y, z, t, a, b): return (x / a) / y
function code(x, y, z, t, a, b) return Float64(Float64(x / a) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x / a) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{x}{a}}{y}
\end{array}
Initial program 98.9%
Taylor expanded in b around 0 81.4%
exp-sum68.9%
*-commutative68.9%
exp-to-pow68.9%
exp-to-pow69.6%
sub-neg69.6%
metadata-eval69.6%
Simplified69.6%
Taylor expanded in t around 0 62.3%
Taylor expanded in y around 0 34.7%
Final simplification34.7%
(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 2024018
(FPCore (x y z t a b)
:name "Numeric.SpecFunctions:incompleteBetaWorker from math-functions-0.1.5.2, A"
:precision binary64
:herbie-target
(if (< t -0.8845848504127471) (/ (* x (/ (pow a (- t 1.0)) y)) (- (+ b 1.0) (* y (log z)))) (if (< t 852031.2288374073) (/ (* (/ x y) (pow a (- t 1.0))) (exp (- b (* (log z) y)))) (/ (* x (/ (pow a (- t 1.0)) y)) (- (+ b 1.0) (* y (log z))))))
(/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))