
(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 29 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}
\end{array}
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (+ t -1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t + (-1.0d0)) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t + -1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t + -1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t + -1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t + -1\right) \cdot \log a\right) - b}}{y}
\end{array}
Initial program 97.8%
Final simplification97.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (/ (pow a (+ t -1.0)) y) (exp b))))
(t_2 (* (/ x y) (exp (* y (log z))))))
(if (<= y -9.5e+171)
t_2
(if (<= y -4.1e+80)
t_1
(if (<= y -115.0)
(/ (* x (pow z y)) (* y a))
(if (<= y 1.65e-168)
t_1
(if (<= y 3.2e-117)
(/ (* x (pow a t)) (* y a))
(if (<= y 2.5e-28) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * ((pow(a, (t + -1.0)) / y) / exp(b));
double t_2 = (x / y) * exp((y * log(z)));
double tmp;
if (y <= -9.5e+171) {
tmp = t_2;
} else if (y <= -4.1e+80) {
tmp = t_1;
} else if (y <= -115.0) {
tmp = (x * pow(z, y)) / (y * a);
} else if (y <= 1.65e-168) {
tmp = t_1;
} else if (y <= 3.2e-117) {
tmp = (x * pow(a, t)) / (y * a);
} else if (y <= 2.5e-28) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * (((a ** (t + (-1.0d0))) / y) / exp(b))
t_2 = (x / y) * exp((y * log(z)))
if (y <= (-9.5d+171)) then
tmp = t_2
else if (y <= (-4.1d+80)) then
tmp = t_1
else if (y <= (-115.0d0)) then
tmp = (x * (z ** y)) / (y * a)
else if (y <= 1.65d-168) then
tmp = t_1
else if (y <= 3.2d-117) then
tmp = (x * (a ** t)) / (y * a)
else if (y <= 2.5d-28) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * ((Math.pow(a, (t + -1.0)) / y) / Math.exp(b));
double t_2 = (x / y) * Math.exp((y * Math.log(z)));
double tmp;
if (y <= -9.5e+171) {
tmp = t_2;
} else if (y <= -4.1e+80) {
tmp = t_1;
} else if (y <= -115.0) {
tmp = (x * Math.pow(z, y)) / (y * a);
} else if (y <= 1.65e-168) {
tmp = t_1;
} else if (y <= 3.2e-117) {
tmp = (x * Math.pow(a, t)) / (y * a);
} else if (y <= 2.5e-28) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * ((math.pow(a, (t + -1.0)) / y) / math.exp(b)) t_2 = (x / y) * math.exp((y * math.log(z))) tmp = 0 if y <= -9.5e+171: tmp = t_2 elif y <= -4.1e+80: tmp = t_1 elif y <= -115.0: tmp = (x * math.pow(z, y)) / (y * a) elif y <= 1.65e-168: tmp = t_1 elif y <= 3.2e-117: tmp = (x * math.pow(a, t)) / (y * a) elif y <= 2.5e-28: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(Float64((a ^ Float64(t + -1.0)) / y) / exp(b))) t_2 = Float64(Float64(x / y) * exp(Float64(y * log(z)))) tmp = 0.0 if (y <= -9.5e+171) tmp = t_2; elseif (y <= -4.1e+80) tmp = t_1; elseif (y <= -115.0) tmp = Float64(Float64(x * (z ^ y)) / Float64(y * a)); elseif (y <= 1.65e-168) tmp = t_1; elseif (y <= 3.2e-117) tmp = Float64(Float64(x * (a ^ t)) / Float64(y * a)); elseif (y <= 2.5e-28) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (((a ^ (t + -1.0)) / y) / exp(b)); t_2 = (x / y) * exp((y * log(z))); tmp = 0.0; if (y <= -9.5e+171) tmp = t_2; elseif (y <= -4.1e+80) tmp = t_1; elseif (y <= -115.0) tmp = (x * (z ^ y)) / (y * a); elseif (y <= 1.65e-168) tmp = t_1; elseif (y <= 3.2e-117) tmp = (x * (a ^ t)) / (y * a); elseif (y <= 2.5e-28) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision] / N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / y), $MachinePrecision] * N[Exp[N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9.5e+171], t$95$2, If[LessEqual[y, -4.1e+80], t$95$1, If[LessEqual[y, -115.0], N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.65e-168], t$95$1, If[LessEqual[y, 3.2e-117], N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e-28], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{\frac{{a}^{\left(t + -1\right)}}{y}}{e^{b}}\\
t_2 := \frac{x}{y} \cdot e^{y \cdot \log z}\\
\mathbf{if}\;y \leq -9.5 \cdot 10^{+171}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -4.1 \cdot 10^{+80}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -115:\\
\;\;\;\;\frac{x \cdot {z}^{y}}{y \cdot a}\\
\mathbf{elif}\;y \leq 1.65 \cdot 10^{-168}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.2 \cdot 10^{-117}:\\
\;\;\;\;\frac{x \cdot {a}^{t}}{y \cdot a}\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{-28}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -9.49999999999999924e171 or 2.5000000000000001e-28 < y Initial program 100.0%
*-commutative100.0%
associate-/l*94.1%
associate--l+94.1%
fma-define94.1%
sub-neg94.1%
metadata-eval94.1%
Simplified94.1%
Taylor expanded in y around inf 82.4%
if -9.49999999999999924e171 < y < -4.10000000000000001e80 or -115 < y < 1.6500000000000001e-168 or 3.19999999999999995e-117 < y < 2.5000000000000001e-28Initial program 95.8%
associate-/l*96.5%
associate--l+96.5%
exp-sum93.4%
associate-/l*92.7%
*-commutative92.7%
exp-to-pow92.7%
exp-diff82.1%
*-commutative82.1%
exp-to-pow83.3%
sub-neg83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in y around 0 83.7%
associate-/r*82.1%
exp-to-pow83.3%
sub-neg83.3%
metadata-eval83.3%
Simplified83.3%
if -4.10000000000000001e80 < y < -115Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum80.0%
associate-/l*80.0%
*-commutative80.0%
exp-to-pow80.0%
exp-diff60.0%
*-commutative60.0%
exp-to-pow60.0%
sub-neg60.0%
metadata-eval60.0%
Simplified60.0%
Taylor expanded in t around 0 80.0%
Taylor expanded in b around 0 90.2%
*-commutative90.2%
Simplified90.2%
if 1.6500000000000001e-168 < y < 3.19999999999999995e-117Initial program 98.6%
*-commutative98.6%
associate-/l*84.4%
associate--l+84.4%
fma-define84.4%
sub-neg84.4%
metadata-eval84.4%
Simplified84.4%
Taylor expanded in y around 0 84.4%
exp-diff53.6%
sub-neg53.6%
metadata-eval53.6%
pow-to-exp54.4%
unpow-prod-up54.4%
exp-to-pow54.4%
associate-/l*54.4%
exp-to-pow54.4%
unpow-154.4%
Applied egg-rr54.4%
associate-/r*54.4%
associate-*r/54.4%
*-rgt-identity54.4%
Simplified54.4%
Taylor expanded in b around 0 100.0%
Final simplification84.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (/ (pow a (+ t -1.0)) y) (exp b))))
(t_2 (* (/ x y) (exp (* y (log z))))))
(if (<= y -4.2e+172)
t_2
(if (<= y -2.45e+82)
t_1
(if (<= y -1300.0)
(/ (* x (pow z y)) (* y a))
(if (<= y 9e-169)
t_1
(if (<= y 3.3e-117)
(/ (* x (pow a t)) (* y a))
(if (<= y 2.5e-28)
(* (/ x y) (/ (pow a t) (* a (exp b))))
t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * ((pow(a, (t + -1.0)) / y) / exp(b));
double t_2 = (x / y) * exp((y * log(z)));
double tmp;
if (y <= -4.2e+172) {
tmp = t_2;
} else if (y <= -2.45e+82) {
tmp = t_1;
} else if (y <= -1300.0) {
tmp = (x * pow(z, y)) / (y * a);
} else if (y <= 9e-169) {
tmp = t_1;
} else if (y <= 3.3e-117) {
tmp = (x * pow(a, t)) / (y * a);
} else if (y <= 2.5e-28) {
tmp = (x / y) * (pow(a, t) / (a * exp(b)));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * (((a ** (t + (-1.0d0))) / y) / exp(b))
t_2 = (x / y) * exp((y * log(z)))
if (y <= (-4.2d+172)) then
tmp = t_2
else if (y <= (-2.45d+82)) then
tmp = t_1
else if (y <= (-1300.0d0)) then
tmp = (x * (z ** y)) / (y * a)
else if (y <= 9d-169) then
tmp = t_1
else if (y <= 3.3d-117) then
tmp = (x * (a ** t)) / (y * a)
else if (y <= 2.5d-28) then
tmp = (x / y) * ((a ** t) / (a * exp(b)))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * ((Math.pow(a, (t + -1.0)) / y) / Math.exp(b));
double t_2 = (x / y) * Math.exp((y * Math.log(z)));
double tmp;
if (y <= -4.2e+172) {
tmp = t_2;
} else if (y <= -2.45e+82) {
tmp = t_1;
} else if (y <= -1300.0) {
tmp = (x * Math.pow(z, y)) / (y * a);
} else if (y <= 9e-169) {
tmp = t_1;
} else if (y <= 3.3e-117) {
tmp = (x * Math.pow(a, t)) / (y * a);
} else if (y <= 2.5e-28) {
tmp = (x / y) * (Math.pow(a, t) / (a * Math.exp(b)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * ((math.pow(a, (t + -1.0)) / y) / math.exp(b)) t_2 = (x / y) * math.exp((y * math.log(z))) tmp = 0 if y <= -4.2e+172: tmp = t_2 elif y <= -2.45e+82: tmp = t_1 elif y <= -1300.0: tmp = (x * math.pow(z, y)) / (y * a) elif y <= 9e-169: tmp = t_1 elif y <= 3.3e-117: tmp = (x * math.pow(a, t)) / (y * a) elif y <= 2.5e-28: tmp = (x / y) * (math.pow(a, t) / (a * math.exp(b))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(Float64((a ^ Float64(t + -1.0)) / y) / exp(b))) t_2 = Float64(Float64(x / y) * exp(Float64(y * log(z)))) tmp = 0.0 if (y <= -4.2e+172) tmp = t_2; elseif (y <= -2.45e+82) tmp = t_1; elseif (y <= -1300.0) tmp = Float64(Float64(x * (z ^ y)) / Float64(y * a)); elseif (y <= 9e-169) tmp = t_1; elseif (y <= 3.3e-117) tmp = Float64(Float64(x * (a ^ t)) / Float64(y * a)); elseif (y <= 2.5e-28) tmp = Float64(Float64(x / y) * Float64((a ^ t) / Float64(a * exp(b)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (((a ^ (t + -1.0)) / y) / exp(b)); t_2 = (x / y) * exp((y * log(z))); tmp = 0.0; if (y <= -4.2e+172) tmp = t_2; elseif (y <= -2.45e+82) tmp = t_1; elseif (y <= -1300.0) tmp = (x * (z ^ y)) / (y * a); elseif (y <= 9e-169) tmp = t_1; elseif (y <= 3.3e-117) tmp = (x * (a ^ t)) / (y * a); elseif (y <= 2.5e-28) tmp = (x / y) * ((a ^ t) / (a * exp(b))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision] / N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / y), $MachinePrecision] * N[Exp[N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.2e+172], t$95$2, If[LessEqual[y, -2.45e+82], t$95$1, If[LessEqual[y, -1300.0], N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9e-169], t$95$1, If[LessEqual[y, 3.3e-117], N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e-28], N[(N[(x / y), $MachinePrecision] * N[(N[Power[a, t], $MachinePrecision] / N[(a * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{\frac{{a}^{\left(t + -1\right)}}{y}}{e^{b}}\\
t_2 := \frac{x}{y} \cdot e^{y \cdot \log z}\\
\mathbf{if}\;y \leq -4.2 \cdot 10^{+172}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -2.45 \cdot 10^{+82}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1300:\\
\;\;\;\;\frac{x \cdot {z}^{y}}{y \cdot a}\\
\mathbf{elif}\;y \leq 9 \cdot 10^{-169}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{-117}:\\
\;\;\;\;\frac{x \cdot {a}^{t}}{y \cdot a}\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{-28}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{{a}^{t}}{a \cdot e^{b}}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -4.2000000000000003e172 or 2.5000000000000001e-28 < y Initial program 100.0%
*-commutative100.0%
associate-/l*94.1%
associate--l+94.1%
fma-define94.1%
sub-neg94.1%
metadata-eval94.1%
Simplified94.1%
Taylor expanded in y around inf 82.4%
if -4.2000000000000003e172 < y < -2.45e82 or -1300 < y < 8.9999999999999997e-169Initial program 95.6%
associate-/l*96.3%
associate--l+96.3%
exp-sum92.8%
associate-/l*91.9%
*-commutative91.9%
exp-to-pow91.9%
exp-diff80.6%
*-commutative80.6%
exp-to-pow81.7%
sub-neg81.7%
metadata-eval81.7%
Simplified81.7%
Taylor expanded in y around 0 82.4%
associate-/r*81.5%
exp-to-pow82.6%
sub-neg82.6%
metadata-eval82.6%
Simplified82.6%
if -2.45e82 < y < -1300Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum80.0%
associate-/l*80.0%
*-commutative80.0%
exp-to-pow80.0%
exp-diff60.0%
*-commutative60.0%
exp-to-pow60.0%
sub-neg60.0%
metadata-eval60.0%
Simplified60.0%
Taylor expanded in t around 0 80.0%
Taylor expanded in b around 0 90.2%
*-commutative90.2%
Simplified90.2%
if 8.9999999999999997e-169 < y < 3.30000000000000015e-117Initial program 98.6%
*-commutative98.6%
associate-/l*84.4%
associate--l+84.4%
fma-define84.4%
sub-neg84.4%
metadata-eval84.4%
Simplified84.4%
Taylor expanded in y around 0 84.4%
exp-diff53.6%
sub-neg53.6%
metadata-eval53.6%
pow-to-exp54.4%
unpow-prod-up54.4%
exp-to-pow54.4%
associate-/l*54.4%
exp-to-pow54.4%
unpow-154.4%
Applied egg-rr54.4%
associate-/r*54.4%
associate-*r/54.4%
*-rgt-identity54.4%
Simplified54.4%
Taylor expanded in b around 0 100.0%
if 3.30000000000000015e-117 < y < 2.5000000000000001e-28Initial program 97.8%
*-commutative97.8%
associate-/l*97.8%
associate--l+97.8%
fma-define97.8%
sub-neg97.8%
metadata-eval97.8%
Simplified97.8%
Taylor expanded in y around 0 97.8%
exp-diff92.1%
sub-neg92.1%
metadata-eval92.1%
pow-to-exp94.0%
unpow-prod-up94.0%
exp-to-pow94.0%
associate-/l*94.0%
exp-to-pow94.0%
unpow-194.0%
Applied egg-rr94.0%
associate-/r*94.0%
associate-*r/94.0%
*-rgt-identity94.0%
Simplified94.0%
Final simplification84.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* x (pow z y)) (* a (* y (exp b)))))
(t_2 (/ (* x (pow a t)) y)))
(if (<= (+ t -1.0) -2e+28)
t_2
(if (<= (+ t -1.0) 2e+28)
t_1
(if (<= (+ t -1.0) 2e+208)
t_2
(if (<= (+ t -1.0) 1e+238) t_1 (* x (/ (pow a (+ t -1.0)) y))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * pow(z, y)) / (a * (y * exp(b)));
double t_2 = (x * pow(a, t)) / y;
double tmp;
if ((t + -1.0) <= -2e+28) {
tmp = t_2;
} else if ((t + -1.0) <= 2e+28) {
tmp = t_1;
} else if ((t + -1.0) <= 2e+208) {
tmp = t_2;
} else if ((t + -1.0) <= 1e+238) {
tmp = t_1;
} else {
tmp = x * (pow(a, (t + -1.0)) / y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x * (z ** y)) / (a * (y * exp(b)))
t_2 = (x * (a ** t)) / y
if ((t + (-1.0d0)) <= (-2d+28)) then
tmp = t_2
else if ((t + (-1.0d0)) <= 2d+28) then
tmp = t_1
else if ((t + (-1.0d0)) <= 2d+208) then
tmp = t_2
else if ((t + (-1.0d0)) <= 1d+238) then
tmp = t_1
else
tmp = x * ((a ** (t + (-1.0d0))) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * Math.pow(z, y)) / (a * (y * Math.exp(b)));
double t_2 = (x * Math.pow(a, t)) / y;
double tmp;
if ((t + -1.0) <= -2e+28) {
tmp = t_2;
} else if ((t + -1.0) <= 2e+28) {
tmp = t_1;
} else if ((t + -1.0) <= 2e+208) {
tmp = t_2;
} else if ((t + -1.0) <= 1e+238) {
tmp = t_1;
} else {
tmp = x * (Math.pow(a, (t + -1.0)) / y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x * math.pow(z, y)) / (a * (y * math.exp(b))) t_2 = (x * math.pow(a, t)) / y tmp = 0 if (t + -1.0) <= -2e+28: tmp = t_2 elif (t + -1.0) <= 2e+28: tmp = t_1 elif (t + -1.0) <= 2e+208: tmp = t_2 elif (t + -1.0) <= 1e+238: tmp = t_1 else: tmp = x * (math.pow(a, (t + -1.0)) / y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * (z ^ y)) / Float64(a * Float64(y * exp(b)))) t_2 = Float64(Float64(x * (a ^ t)) / y) tmp = 0.0 if (Float64(t + -1.0) <= -2e+28) tmp = t_2; elseif (Float64(t + -1.0) <= 2e+28) tmp = t_1; elseif (Float64(t + -1.0) <= 2e+208) tmp = t_2; elseif (Float64(t + -1.0) <= 1e+238) tmp = t_1; else tmp = Float64(x * Float64((a ^ Float64(t + -1.0)) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x * (z ^ y)) / (a * (y * exp(b))); t_2 = (x * (a ^ t)) / y; tmp = 0.0; if ((t + -1.0) <= -2e+28) tmp = t_2; elseif ((t + -1.0) <= 2e+28) tmp = t_1; elseif ((t + -1.0) <= 2e+208) tmp = t_2; elseif ((t + -1.0) <= 1e+238) tmp = t_1; else tmp = x * ((a ^ (t + -1.0)) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[N[(t + -1.0), $MachinePrecision], -2e+28], t$95$2, If[LessEqual[N[(t + -1.0), $MachinePrecision], 2e+28], t$95$1, If[LessEqual[N[(t + -1.0), $MachinePrecision], 2e+208], t$95$2, If[LessEqual[N[(t + -1.0), $MachinePrecision], 1e+238], t$95$1, N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot {z}^{y}}{a \cdot \left(y \cdot e^{b}\right)}\\
t_2 := \frac{x \cdot {a}^{t}}{y}\\
\mathbf{if}\;t + -1 \leq -2 \cdot 10^{+28}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t + -1 \leq 2 \cdot 10^{+28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t + -1 \leq 2 \cdot 10^{+208}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t + -1 \leq 10^{+238}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{{a}^{\left(t + -1\right)}}{y}\\
\end{array}
\end{array}
if (-.f64 t #s(literal 1 binary64)) < -1.99999999999999992e28 or 1.99999999999999992e28 < (-.f64 t #s(literal 1 binary64)) < 2e208Initial program 100.0%
*-commutative100.0%
associate-/l*87.2%
associate--l+87.2%
fma-define87.2%
sub-neg87.2%
metadata-eval87.2%
Simplified87.2%
Taylor expanded in t around inf 68.3%
*-commutative68.3%
Simplified68.3%
Taylor expanded in a around 0 81.2%
if -1.99999999999999992e28 < (-.f64 t #s(literal 1 binary64)) < 1.99999999999999992e28 or 2e208 < (-.f64 t #s(literal 1 binary64)) < 1e238Initial program 96.1%
associate-/l*96.6%
associate--l+96.6%
exp-sum88.3%
associate-/l*86.2%
*-commutative86.2%
exp-to-pow86.2%
exp-diff83.5%
*-commutative83.5%
exp-to-pow84.7%
sub-neg84.7%
metadata-eval84.7%
Simplified84.7%
Taylor expanded in t around 0 89.9%
if 1e238 < (-.f64 t #s(literal 1 binary64)) Initial program 100.0%
*-commutative100.0%
associate-/l*94.4%
associate--l+94.4%
fma-define94.4%
sub-neg94.4%
metadata-eval94.4%
Simplified94.4%
Taylor expanded in y around 0 89.1%
Taylor expanded in b around 0 89.1%
associate-/l*89.1%
exp-to-pow89.1%
sub-neg89.1%
metadata-eval89.1%
+-commutative89.1%
Simplified89.1%
Final simplification86.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* x (pow z y)) (* a (* y (exp b))))))
(if (<= (+ t -1.0) -1e+15)
(* (exp (- (* (+ t -1.0) (log a)) b)) (/ x y))
(if (<= (+ t -1.0) 2e+28)
t_1
(if (<= (+ t -1.0) 2e+208)
(/ (* x (pow a t)) y)
(if (<= (+ t -1.0) 1e+238) t_1 (* x (/ (pow a (+ t -1.0)) y))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * pow(z, y)) / (a * (y * exp(b)));
double tmp;
if ((t + -1.0) <= -1e+15) {
tmp = exp((((t + -1.0) * log(a)) - b)) * (x / y);
} else if ((t + -1.0) <= 2e+28) {
tmp = t_1;
} else if ((t + -1.0) <= 2e+208) {
tmp = (x * pow(a, t)) / y;
} else if ((t + -1.0) <= 1e+238) {
tmp = t_1;
} else {
tmp = x * (pow(a, (t + -1.0)) / y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = (x * (z ** y)) / (a * (y * exp(b)))
if ((t + (-1.0d0)) <= (-1d+15)) then
tmp = exp((((t + (-1.0d0)) * log(a)) - b)) * (x / y)
else if ((t + (-1.0d0)) <= 2d+28) then
tmp = t_1
else if ((t + (-1.0d0)) <= 2d+208) then
tmp = (x * (a ** t)) / y
else if ((t + (-1.0d0)) <= 1d+238) then
tmp = t_1
else
tmp = x * ((a ** (t + (-1.0d0))) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * Math.pow(z, y)) / (a * (y * Math.exp(b)));
double tmp;
if ((t + -1.0) <= -1e+15) {
tmp = Math.exp((((t + -1.0) * Math.log(a)) - b)) * (x / y);
} else if ((t + -1.0) <= 2e+28) {
tmp = t_1;
} else if ((t + -1.0) <= 2e+208) {
tmp = (x * Math.pow(a, t)) / y;
} else if ((t + -1.0) <= 1e+238) {
tmp = t_1;
} else {
tmp = x * (Math.pow(a, (t + -1.0)) / y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x * math.pow(z, y)) / (a * (y * math.exp(b))) tmp = 0 if (t + -1.0) <= -1e+15: tmp = math.exp((((t + -1.0) * math.log(a)) - b)) * (x / y) elif (t + -1.0) <= 2e+28: tmp = t_1 elif (t + -1.0) <= 2e+208: tmp = (x * math.pow(a, t)) / y elif (t + -1.0) <= 1e+238: tmp = t_1 else: tmp = x * (math.pow(a, (t + -1.0)) / y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * (z ^ y)) / Float64(a * Float64(y * exp(b)))) tmp = 0.0 if (Float64(t + -1.0) <= -1e+15) tmp = Float64(exp(Float64(Float64(Float64(t + -1.0) * log(a)) - b)) * Float64(x / y)); elseif (Float64(t + -1.0) <= 2e+28) tmp = t_1; elseif (Float64(t + -1.0) <= 2e+208) tmp = Float64(Float64(x * (a ^ t)) / y); elseif (Float64(t + -1.0) <= 1e+238) tmp = t_1; else tmp = Float64(x * Float64((a ^ Float64(t + -1.0)) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x * (z ^ y)) / (a * (y * exp(b))); tmp = 0.0; if ((t + -1.0) <= -1e+15) tmp = exp((((t + -1.0) * log(a)) - b)) * (x / y); elseif ((t + -1.0) <= 2e+28) tmp = t_1; elseif ((t + -1.0) <= 2e+208) tmp = (x * (a ^ t)) / y; elseif ((t + -1.0) <= 1e+238) tmp = t_1; else tmp = x * ((a ^ (t + -1.0)) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t + -1.0), $MachinePrecision], -1e+15], N[(N[Exp[N[(N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(t + -1.0), $MachinePrecision], 2e+28], t$95$1, If[LessEqual[N[(t + -1.0), $MachinePrecision], 2e+208], N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[N[(t + -1.0), $MachinePrecision], 1e+238], t$95$1, N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot {z}^{y}}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{if}\;t + -1 \leq -1 \cdot 10^{+15}:\\
\;\;\;\;e^{\left(t + -1\right) \cdot \log a - b} \cdot \frac{x}{y}\\
\mathbf{elif}\;t + -1 \leq 2 \cdot 10^{+28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t + -1 \leq 2 \cdot 10^{+208}:\\
\;\;\;\;\frac{x \cdot {a}^{t}}{y}\\
\mathbf{elif}\;t + -1 \leq 10^{+238}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{{a}^{\left(t + -1\right)}}{y}\\
\end{array}
\end{array}
if (-.f64 t #s(literal 1 binary64)) < -1e15Initial program 100.0%
*-commutative100.0%
associate-/l*90.0%
associate--l+90.0%
fma-define90.0%
sub-neg90.0%
metadata-eval90.0%
Simplified90.0%
Taylor expanded in y around 0 81.7%
if -1e15 < (-.f64 t #s(literal 1 binary64)) < 1.99999999999999992e28 or 2e208 < (-.f64 t #s(literal 1 binary64)) < 1e238Initial program 96.0%
associate-/l*96.6%
associate--l+96.6%
exp-sum88.1%
associate-/l*85.9%
*-commutative85.9%
exp-to-pow85.9%
exp-diff83.8%
*-commutative83.8%
exp-to-pow85.0%
sub-neg85.0%
metadata-eval85.0%
Simplified85.0%
Taylor expanded in t around 0 90.3%
if 1.99999999999999992e28 < (-.f64 t #s(literal 1 binary64)) < 2e208Initial program 100.0%
*-commutative100.0%
associate-/l*83.8%
associate--l+83.8%
fma-define83.8%
sub-neg83.8%
metadata-eval83.8%
Simplified83.8%
Taylor expanded in t around inf 65.1%
*-commutative65.1%
Simplified65.1%
Taylor expanded in a around 0 81.4%
if 1e238 < (-.f64 t #s(literal 1 binary64)) Initial program 100.0%
*-commutative100.0%
associate-/l*94.4%
associate--l+94.4%
fma-define94.4%
sub-neg94.4%
metadata-eval94.4%
Simplified94.4%
Taylor expanded in y around 0 89.1%
Taylor expanded in b around 0 89.1%
associate-/l*89.1%
exp-to-pow89.1%
sub-neg89.1%
metadata-eval89.1%
+-commutative89.1%
Simplified89.1%
Final simplification86.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (pow a (+ t -1.0)) y))))
(if (<= y -255.0)
(/ (* x (pow z y)) (* y a))
(if (<= y -3.8e-143)
t_1
(if (<= y -5.8e-271)
(/ (* x (/ (exp (- b)) a)) y)
(if (<= y 17.0) t_1 (* (/ x y) (exp (* y (log z))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (pow(a, (t + -1.0)) / y);
double tmp;
if (y <= -255.0) {
tmp = (x * pow(z, y)) / (y * a);
} else if (y <= -3.8e-143) {
tmp = t_1;
} else if (y <= -5.8e-271) {
tmp = (x * (exp(-b) / a)) / y;
} else if (y <= 17.0) {
tmp = t_1;
} else {
tmp = (x / y) * exp((y * log(z)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((a ** (t + (-1.0d0))) / y)
if (y <= (-255.0d0)) then
tmp = (x * (z ** y)) / (y * a)
else if (y <= (-3.8d-143)) then
tmp = t_1
else if (y <= (-5.8d-271)) then
tmp = (x * (exp(-b) / a)) / y
else if (y <= 17.0d0) then
tmp = t_1
else
tmp = (x / y) * exp((y * log(z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (Math.pow(a, (t + -1.0)) / y);
double tmp;
if (y <= -255.0) {
tmp = (x * Math.pow(z, y)) / (y * a);
} else if (y <= -3.8e-143) {
tmp = t_1;
} else if (y <= -5.8e-271) {
tmp = (x * (Math.exp(-b) / a)) / y;
} else if (y <= 17.0) {
tmp = t_1;
} else {
tmp = (x / y) * Math.exp((y * Math.log(z)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * (math.pow(a, (t + -1.0)) / y) tmp = 0 if y <= -255.0: tmp = (x * math.pow(z, y)) / (y * a) elif y <= -3.8e-143: tmp = t_1 elif y <= -5.8e-271: tmp = (x * (math.exp(-b) / a)) / y elif y <= 17.0: tmp = t_1 else: tmp = (x / y) * math.exp((y * math.log(z))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64((a ^ Float64(t + -1.0)) / y)) tmp = 0.0 if (y <= -255.0) tmp = Float64(Float64(x * (z ^ y)) / Float64(y * a)); elseif (y <= -3.8e-143) tmp = t_1; elseif (y <= -5.8e-271) tmp = Float64(Float64(x * Float64(exp(Float64(-b)) / a)) / y); elseif (y <= 17.0) tmp = t_1; else tmp = Float64(Float64(x / y) * exp(Float64(y * log(z)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * ((a ^ (t + -1.0)) / y); tmp = 0.0; if (y <= -255.0) tmp = (x * (z ^ y)) / (y * a); elseif (y <= -3.8e-143) tmp = t_1; elseif (y <= -5.8e-271) tmp = (x * (exp(-b) / a)) / y; elseif (y <= 17.0) tmp = t_1; else tmp = (x / y) * exp((y * log(z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -255.0], N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -3.8e-143], t$95$1, If[LessEqual[y, -5.8e-271], N[(N[(x * N[(N[Exp[(-b)], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[y, 17.0], t$95$1, N[(N[(x / y), $MachinePrecision] * N[Exp[N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{{a}^{\left(t + -1\right)}}{y}\\
\mathbf{if}\;y \leq -255:\\
\;\;\;\;\frac{x \cdot {z}^{y}}{y \cdot a}\\
\mathbf{elif}\;y \leq -3.8 \cdot 10^{-143}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -5.8 \cdot 10^{-271}:\\
\;\;\;\;\frac{x \cdot \frac{e^{-b}}{a}}{y}\\
\mathbf{elif}\;y \leq 17:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot e^{y \cdot \log z}\\
\end{array}
\end{array}
if y < -255Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum67.9%
associate-/l*66.0%
*-commutative66.0%
exp-to-pow66.0%
exp-diff62.3%
*-commutative62.3%
exp-to-pow62.3%
sub-neg62.3%
metadata-eval62.3%
Simplified62.3%
Taylor expanded in t around 0 75.6%
Taylor expanded in b around 0 81.3%
*-commutative81.3%
Simplified81.3%
if -255 < y < -3.79999999999999981e-143 or -5.80000000000000028e-271 < y < 17Initial program 94.8%
*-commutative94.8%
associate-/l*87.8%
associate--l+87.8%
fma-define87.8%
sub-neg87.8%
metadata-eval87.8%
Simplified87.8%
Taylor expanded in y around 0 94.8%
Taylor expanded in b around 0 77.5%
associate-/l*79.2%
exp-to-pow80.6%
sub-neg80.6%
metadata-eval80.6%
+-commutative80.6%
Simplified80.6%
if -3.79999999999999981e-143 < y < -5.80000000000000028e-271Initial program 98.8%
*-commutative98.8%
associate-/l*86.8%
associate--l+86.8%
fma-define86.8%
sub-neg86.8%
metadata-eval86.8%
Simplified86.8%
Taylor expanded in y around 0 98.8%
Taylor expanded in t around 0 95.0%
*-commutative95.0%
exp-diff95.0%
mul-1-neg95.0%
log-rec95.0%
rem-exp-log96.2%
associate-/l/96.2%
associate-/r*96.2%
exp-neg96.2%
Simplified96.2%
if 17 < y Initial program 100.0%
*-commutative100.0%
associate-/l*92.0%
associate--l+92.0%
fma-define92.0%
sub-neg92.0%
metadata-eval92.0%
Simplified92.0%
Taylor expanded in y around inf 78.9%
Final simplification81.8%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -440.0) (not (<= t 1.95e+28))) (/ (* x (exp (- (* (+ t -1.0) (log a)) b))) y) (/ (* x (pow z y)) (* a (* y (exp b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -440.0) || !(t <= 1.95e+28)) {
tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y;
} else {
tmp = (x * pow(z, y)) / (a * (y * exp(b)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((t <= (-440.0d0)) .or. (.not. (t <= 1.95d+28))) then
tmp = (x * exp((((t + (-1.0d0)) * log(a)) - b))) / y
else
tmp = (x * (z ** y)) / (a * (y * exp(b)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -440.0) || !(t <= 1.95e+28)) {
tmp = (x * Math.exp((((t + -1.0) * Math.log(a)) - b))) / y;
} else {
tmp = (x * Math.pow(z, y)) / (a * (y * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -440.0) or not (t <= 1.95e+28): tmp = (x * math.exp((((t + -1.0) * math.log(a)) - b))) / y else: tmp = (x * math.pow(z, y)) / (a * (y * math.exp(b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -440.0) || !(t <= 1.95e+28)) tmp = Float64(Float64(x * exp(Float64(Float64(Float64(t + -1.0) * log(a)) - b))) / y); else tmp = Float64(Float64(x * (z ^ y)) / Float64(a * Float64(y * exp(b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -440.0) || ~((t <= 1.95e+28))) tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y; else tmp = (x * (z ^ y)) / (a * (y * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -440.0], N[Not[LessEqual[t, 1.95e+28]], $MachinePrecision]], N[(N[(x * N[Exp[N[(N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -440 \lor \neg \left(t \leq 1.95 \cdot 10^{+28}\right):\\
\;\;\;\;\frac{x \cdot e^{\left(t + -1\right) \cdot \log a - b}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot {z}^{y}}{a \cdot \left(y \cdot e^{b}\right)}\\
\end{array}
\end{array}
if t < -440 or 1.9499999999999999e28 < t Initial program 100.0%
*-commutative100.0%
associate-/l*88.3%
associate--l+88.3%
fma-define88.3%
sub-neg88.3%
metadata-eval88.3%
Simplified88.3%
Taylor expanded in y around 0 88.5%
if -440 < t < 1.9499999999999999e28Initial program 95.6%
associate-/l*96.2%
associate--l+96.2%
exp-sum90.0%
associate-/l*87.6%
*-commutative87.6%
exp-to-pow87.6%
exp-diff87.7%
*-commutative87.7%
exp-to-pow89.0%
sub-neg89.0%
metadata-eval89.0%
Simplified89.0%
Taylor expanded in t around 0 90.8%
Final simplification89.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* y (exp b)))) (t_2 (/ (* x (pow a t)) y)))
(if (<= t -1.45e+55)
t_2
(if (<= t -6.4e-177)
t_1
(if (<= t -9.6e-276)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(if (<= t 1.4e-307)
t_1
(if (<= t 1.9e-88)
(/ -1.0 (* a (/ y (- (* x b) x))))
(if (<= t 4.2)
(/
(*
x
(+
(/ 1.0 a)
(*
b
(-
(/ -1.0 a)
(*
b
(-
(* 0.5 (/ -1.0 a))
(* -0.16666666666666666 (/ b a))))))))
y)
t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y * exp(b));
double t_2 = (x * pow(a, t)) / y;
double tmp;
if (t <= -1.45e+55) {
tmp = t_2;
} else if (t <= -6.4e-177) {
tmp = t_1;
} else if (t <= -9.6e-276) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if (t <= 1.4e-307) {
tmp = t_1;
} else if (t <= 1.9e-88) {
tmp = -1.0 / (a * (y / ((x * b) - x)));
} else if (t <= 4.2) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / 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 = x / (y * exp(b))
t_2 = (x * (a ** t)) / y
if (t <= (-1.45d+55)) then
tmp = t_2
else if (t <= (-6.4d-177)) then
tmp = t_1
else if (t <= (-9.6d-276)) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else if (t <= 1.4d-307) then
tmp = t_1
else if (t <= 1.9d-88) then
tmp = (-1.0d0) / (a * (y / ((x * b) - x)))
else if (t <= 4.2d0) then
tmp = (x * ((1.0d0 / a) + (b * (((-1.0d0) / a) - (b * ((0.5d0 * ((-1.0d0) / a)) - ((-0.16666666666666666d0) * (b / a)))))))) / 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 = x / (y * Math.exp(b));
double t_2 = (x * Math.pow(a, t)) / y;
double tmp;
if (t <= -1.45e+55) {
tmp = t_2;
} else if (t <= -6.4e-177) {
tmp = t_1;
} else if (t <= -9.6e-276) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if (t <= 1.4e-307) {
tmp = t_1;
} else if (t <= 1.9e-88) {
tmp = -1.0 / (a * (y / ((x * b) - x)));
} else if (t <= 4.2) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (y * math.exp(b)) t_2 = (x * math.pow(a, t)) / y tmp = 0 if t <= -1.45e+55: tmp = t_2 elif t <= -6.4e-177: tmp = t_1 elif t <= -9.6e-276: tmp = (b * ((x / (a * b)) - (x / a))) / y elif t <= 1.4e-307: tmp = t_1 elif t <= 1.9e-88: tmp = -1.0 / (a * (y / ((x * b) - x))) elif t <= 4.2: tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y * exp(b))) t_2 = Float64(Float64(x * (a ^ t)) / y) tmp = 0.0 if (t <= -1.45e+55) tmp = t_2; elseif (t <= -6.4e-177) tmp = t_1; elseif (t <= -9.6e-276) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); elseif (t <= 1.4e-307) tmp = t_1; elseif (t <= 1.9e-88) tmp = Float64(-1.0 / Float64(a * Float64(y / Float64(Float64(x * b) - x)))); elseif (t <= 4.2) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(-1.0 / a) - Float64(b * Float64(Float64(0.5 * Float64(-1.0 / a)) - Float64(-0.16666666666666666 * Float64(b / a)))))))) / y); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (y * exp(b)); t_2 = (x * (a ^ t)) / y; tmp = 0.0; if (t <= -1.45e+55) tmp = t_2; elseif (t <= -6.4e-177) tmp = t_1; elseif (t <= -9.6e-276) tmp = (b * ((x / (a * b)) - (x / a))) / y; elseif (t <= 1.4e-307) tmp = t_1; elseif (t <= 1.9e-88) tmp = -1.0 / (a * (y / ((x * b) - x))); elseif (t <= 4.2) tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t, -1.45e+55], t$95$2, If[LessEqual[t, -6.4e-177], t$95$1, If[LessEqual[t, -9.6e-276], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 1.4e-307], t$95$1, If[LessEqual[t, 1.9e-88], N[(-1.0 / N[(a * N[(y / N[(N[(x * b), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.2], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(-1.0 / a), $MachinePrecision] - N[(b * N[(N[(0.5 * N[(-1.0 / a), $MachinePrecision]), $MachinePrecision] - N[(-0.16666666666666666 * N[(b / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y \cdot e^{b}}\\
t_2 := \frac{x \cdot {a}^{t}}{y}\\
\mathbf{if}\;t \leq -1.45 \cdot 10^{+55}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -6.4 \cdot 10^{-177}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -9.6 \cdot 10^{-276}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{-307}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{-88}:\\
\;\;\;\;\frac{-1}{a \cdot \frac{y}{x \cdot b - x}}\\
\mathbf{elif}\;t \leq 4.2:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(\frac{-1}{a} - b \cdot \left(0.5 \cdot \frac{-1}{a} - -0.16666666666666666 \cdot \frac{b}{a}\right)\right)\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -1.4499999999999999e55 or 4.20000000000000018 < t Initial program 100.0%
*-commutative100.0%
associate-/l*88.0%
associate--l+88.0%
fma-define88.0%
sub-neg88.0%
metadata-eval88.0%
Simplified88.0%
Taylor expanded in t around inf 69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in a around 0 80.6%
if -1.4499999999999999e55 < t < -6.3999999999999997e-177 or -9.5999999999999993e-276 < t < 1.4e-307Initial program 97.8%
*-commutative97.8%
associate-/l*94.1%
associate--l+94.1%
fma-define94.1%
sub-neg94.1%
metadata-eval94.1%
Simplified94.1%
Taylor expanded in b around inf 59.0%
neg-mul-159.0%
Simplified59.0%
Taylor expanded in b around inf 60.7%
exp-neg60.7%
associate-*r/60.7%
*-rgt-identity60.7%
associate-/r*60.7%
*-commutative60.7%
Simplified60.7%
if -6.3999999999999997e-177 < t < -9.5999999999999993e-276Initial program 99.5%
*-commutative99.5%
associate-/l*94.9%
associate--l+94.9%
fma-define94.9%
sub-neg94.9%
metadata-eval94.9%
Simplified94.9%
Taylor expanded in y around 0 56.8%
Taylor expanded in t around 0 56.8%
*-commutative56.8%
exp-diff56.8%
mul-1-neg56.8%
log-rec56.8%
rem-exp-log57.1%
associate-/l/57.1%
associate-/r*57.1%
exp-neg57.1%
Simplified57.1%
Taylor expanded in b around 0 52.0%
+-commutative52.0%
mul-1-neg52.0%
unsub-neg52.0%
*-commutative52.0%
associate-/l*52.0%
Simplified52.0%
Taylor expanded in b around inf 57.3%
if 1.4e-307 < t < 1.90000000000000006e-88Initial program 93.4%
*-commutative93.4%
associate-/l*90.7%
associate--l+90.7%
fma-define90.7%
sub-neg90.7%
metadata-eval90.7%
Simplified90.7%
Taylor expanded in y around 0 67.8%
Taylor expanded in t around 0 67.8%
*-commutative67.8%
exp-diff67.9%
mul-1-neg67.9%
log-rec67.9%
rem-exp-log70.0%
associate-/l/70.0%
associate-/r*70.1%
exp-neg70.1%
Simplified70.1%
Taylor expanded in b around 0 41.9%
+-commutative41.9%
mul-1-neg41.9%
unsub-neg41.9%
*-commutative41.9%
associate-/l*41.9%
Simplified41.9%
clear-num41.8%
inv-pow41.8%
associate-*r/41.7%
*-commutative41.7%
sub-div44.0%
Applied egg-rr44.0%
unpow-144.0%
associate-/r/58.7%
*-commutative58.7%
Simplified58.7%
if 1.90000000000000006e-88 < t < 4.20000000000000018Initial program 92.3%
*-commutative92.3%
associate-/l*74.6%
associate--l+74.6%
fma-define74.6%
sub-neg74.6%
metadata-eval74.6%
Simplified74.6%
Taylor expanded in y around 0 80.9%
Taylor expanded in t around 0 80.9%
*-commutative80.9%
exp-diff80.9%
mul-1-neg80.9%
log-rec80.9%
rem-exp-log82.7%
associate-/l/82.7%
associate-/r*82.7%
exp-neg82.7%
Simplified82.7%
Taylor expanded in b around 0 65.3%
Final simplification69.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (exp b) y))))
(if (<= b -1.75e+53)
(/
(*
x
(+
(/ 1.0 a)
(*
b
(-
(/ -1.0 a)
(* b (- (* 0.5 (/ -1.0 a)) (* -0.16666666666666666 (/ b a))))))))
y)
(if (<= b -9e+14)
t_1
(if (<= b -1.75e-35)
(/ (/ (- (* x a) (* a (* x b))) (* a a)) y)
(if (<= b 2.8e-236)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(if (or (<= b 5.5e+55) (not (<= b 1.08e+186)))
(* (/ x y) (/ 1.0 a))
t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (exp(b) / y);
double tmp;
if (b <= -1.75e+53) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= -9e+14) {
tmp = t_1;
} else if (b <= -1.75e-35) {
tmp = (((x * a) - (a * (x * b))) / (a * a)) / y;
} else if (b <= 2.8e-236) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if ((b <= 5.5e+55) || !(b <= 1.08e+186)) {
tmp = (x / y) * (1.0 / a);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x * (exp(b) / y)
if (b <= (-1.75d+53)) then
tmp = (x * ((1.0d0 / a) + (b * (((-1.0d0) / a) - (b * ((0.5d0 * ((-1.0d0) / a)) - ((-0.16666666666666666d0) * (b / a)))))))) / y
else if (b <= (-9d+14)) then
tmp = t_1
else if (b <= (-1.75d-35)) then
tmp = (((x * a) - (a * (x * b))) / (a * a)) / y
else if (b <= 2.8d-236) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else if ((b <= 5.5d+55) .or. (.not. (b <= 1.08d+186))) then
tmp = (x / y) * (1.0d0 / a)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (Math.exp(b) / y);
double tmp;
if (b <= -1.75e+53) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= -9e+14) {
tmp = t_1;
} else if (b <= -1.75e-35) {
tmp = (((x * a) - (a * (x * b))) / (a * a)) / y;
} else if (b <= 2.8e-236) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if ((b <= 5.5e+55) || !(b <= 1.08e+186)) {
tmp = (x / y) * (1.0 / a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * (math.exp(b) / y) tmp = 0 if b <= -1.75e+53: tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y elif b <= -9e+14: tmp = t_1 elif b <= -1.75e-35: tmp = (((x * a) - (a * (x * b))) / (a * a)) / y elif b <= 2.8e-236: tmp = (b * ((x / (a * b)) - (x / a))) / y elif (b <= 5.5e+55) or not (b <= 1.08e+186): tmp = (x / y) * (1.0 / a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64(exp(b) / y)) tmp = 0.0 if (b <= -1.75e+53) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(-1.0 / a) - Float64(b * Float64(Float64(0.5 * Float64(-1.0 / a)) - Float64(-0.16666666666666666 * Float64(b / a)))))))) / y); elseif (b <= -9e+14) tmp = t_1; elseif (b <= -1.75e-35) tmp = Float64(Float64(Float64(Float64(x * a) - Float64(a * Float64(x * b))) / Float64(a * a)) / y); elseif (b <= 2.8e-236) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); elseif ((b <= 5.5e+55) || !(b <= 1.08e+186)) tmp = Float64(Float64(x / y) * Float64(1.0 / a)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (exp(b) / y); tmp = 0.0; if (b <= -1.75e+53) tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y; elseif (b <= -9e+14) tmp = t_1; elseif (b <= -1.75e-35) tmp = (((x * a) - (a * (x * b))) / (a * a)) / y; elseif (b <= 2.8e-236) tmp = (b * ((x / (a * b)) - (x / a))) / y; elseif ((b <= 5.5e+55) || ~((b <= 1.08e+186))) tmp = (x / y) * (1.0 / a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[Exp[b], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.75e+53], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(-1.0 / a), $MachinePrecision] - N[(b * N[(N[(0.5 * N[(-1.0 / a), $MachinePrecision]), $MachinePrecision] - N[(-0.16666666666666666 * N[(b / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -9e+14], t$95$1, If[LessEqual[b, -1.75e-35], N[(N[(N[(N[(x * a), $MachinePrecision] - N[(a * N[(x * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2.8e-236], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[Or[LessEqual[b, 5.5e+55], N[Not[LessEqual[b, 1.08e+186]], $MachinePrecision]], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{e^{b}}{y}\\
\mathbf{if}\;b \leq -1.75 \cdot 10^{+53}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(\frac{-1}{a} - b \cdot \left(0.5 \cdot \frac{-1}{a} - -0.16666666666666666 \cdot \frac{b}{a}\right)\right)\right)}{y}\\
\mathbf{elif}\;b \leq -9 \cdot 10^{+14}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.75 \cdot 10^{-35}:\\
\;\;\;\;\frac{\frac{x \cdot a - a \cdot \left(x \cdot b\right)}{a \cdot a}}{y}\\
\mathbf{elif}\;b \leq 2.8 \cdot 10^{-236}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{elif}\;b \leq 5.5 \cdot 10^{+55} \lor \neg \left(b \leq 1.08 \cdot 10^{+186}\right):\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.75000000000000009e53Initial program 100.0%
*-commutative100.0%
associate-/l*91.7%
associate--l+91.7%
fma-define91.7%
sub-neg91.7%
metadata-eval91.7%
Simplified91.7%
Taylor expanded in y around 0 89.7%
Taylor expanded in t around 0 87.7%
*-commutative87.7%
exp-diff87.7%
mul-1-neg87.7%
log-rec87.7%
rem-exp-log87.7%
associate-/l/87.7%
associate-/r*87.7%
exp-neg87.7%
Simplified87.7%
Taylor expanded in b around 0 87.9%
if -1.75000000000000009e53 < b < -9e14 or 5.5000000000000004e55 < b < 1.08000000000000003e186Initial program 100.0%
*-commutative100.0%
associate-/l*96.2%
associate--l+96.2%
fma-define96.2%
sub-neg96.2%
metadata-eval96.2%
Simplified96.2%
Taylor expanded in b around inf 43.1%
neg-mul-143.1%
Simplified43.1%
associate-*r/43.2%
clear-num43.2%
*-commutative43.2%
add-sqr-sqrt4.1%
sqrt-unprod43.2%
sqr-neg43.2%
sqrt-unprod39.1%
add-sqr-sqrt58.4%
Applied egg-rr58.4%
associate-/r*54.3%
associate-/r/54.3%
associate-/r/54.4%
associate-*l/54.4%
metadata-eval54.4%
distribute-lft-neg-in54.4%
neg-mul-154.4%
remove-double-neg54.4%
associate-*l/58.4%
associate-/l*58.4%
Simplified58.4%
if -9e14 < b < -1.74999999999999998e-35Initial program 100.0%
*-commutative100.0%
associate-/l*100.0%
associate--l+100.0%
fma-define100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around 0 73.4%
Taylor expanded in t around 0 39.0%
*-commutative39.0%
exp-diff39.0%
mul-1-neg39.0%
log-rec39.0%
rem-exp-log39.0%
associate-/l/39.0%
associate-/r*39.0%
exp-neg39.0%
Simplified39.0%
Taylor expanded in b around 0 21.9%
+-commutative21.9%
mul-1-neg21.9%
unsub-neg21.9%
*-commutative21.9%
associate-/l*21.9%
Simplified21.9%
frac-2neg21.9%
associate-*r/21.9%
*-commutative21.9%
frac-sub48.0%
Applied egg-rr48.0%
if -1.74999999999999998e-35 < b < 2.79999999999999986e-236Initial program 96.2%
*-commutative96.2%
associate-/l*83.3%
associate--l+83.3%
fma-define83.3%
sub-neg83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in y around 0 68.4%
Taylor expanded in t around 0 42.0%
*-commutative42.0%
exp-diff42.0%
mul-1-neg42.0%
log-rec42.0%
rem-exp-log43.3%
associate-/l/43.3%
associate-/r*43.3%
exp-neg43.3%
Simplified43.3%
Taylor expanded in b around 0 43.3%
+-commutative43.3%
mul-1-neg43.3%
unsub-neg43.3%
*-commutative43.3%
associate-/l*43.3%
Simplified43.3%
Taylor expanded in b around inf 49.7%
if 2.79999999999999986e-236 < b < 5.5000000000000004e55 or 1.08000000000000003e186 < b Initial program 97.1%
*-commutative97.1%
associate-/l*90.4%
associate--l+90.4%
fma-define90.4%
sub-neg90.4%
metadata-eval90.4%
Simplified90.4%
Taylor expanded in y around 0 80.7%
Taylor expanded in t around 0 62.2%
*-commutative62.2%
exp-diff62.2%
mul-1-neg62.2%
log-rec62.2%
rem-exp-log63.0%
associate-/l/63.0%
associate-/r*63.0%
exp-neg63.0%
Simplified63.0%
Taylor expanded in b around 0 38.9%
*-commutative38.9%
Simplified38.9%
*-un-lft-identity38.9%
*-commutative38.9%
times-frac44.9%
Applied egg-rr44.9%
Final simplification55.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* x (pow z y)) (* y a)))
(t_2 (* x (/ (pow a (+ t -1.0)) y)))
(t_3 (* y (exp b))))
(if (<= b -5.5e+84)
(/ x t_3)
(if (<= b -4.7e-299)
t_1
(if (<= b 4.6e-219)
t_2
(if (<= b 1.25e-127) t_1 (if (<= b 4.4e+92) t_2 (/ x (* a t_3)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * pow(z, y)) / (y * a);
double t_2 = x * (pow(a, (t + -1.0)) / y);
double t_3 = y * exp(b);
double tmp;
if (b <= -5.5e+84) {
tmp = x / t_3;
} else if (b <= -4.7e-299) {
tmp = t_1;
} else if (b <= 4.6e-219) {
tmp = t_2;
} else if (b <= 1.25e-127) {
tmp = t_1;
} else if (b <= 4.4e+92) {
tmp = t_2;
} else {
tmp = x / (a * t_3);
}
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) :: tmp
t_1 = (x * (z ** y)) / (y * a)
t_2 = x * ((a ** (t + (-1.0d0))) / y)
t_3 = y * exp(b)
if (b <= (-5.5d+84)) then
tmp = x / t_3
else if (b <= (-4.7d-299)) then
tmp = t_1
else if (b <= 4.6d-219) then
tmp = t_2
else if (b <= 1.25d-127) then
tmp = t_1
else if (b <= 4.4d+92) then
tmp = t_2
else
tmp = x / (a * t_3)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * Math.pow(z, y)) / (y * a);
double t_2 = x * (Math.pow(a, (t + -1.0)) / y);
double t_3 = y * Math.exp(b);
double tmp;
if (b <= -5.5e+84) {
tmp = x / t_3;
} else if (b <= -4.7e-299) {
tmp = t_1;
} else if (b <= 4.6e-219) {
tmp = t_2;
} else if (b <= 1.25e-127) {
tmp = t_1;
} else if (b <= 4.4e+92) {
tmp = t_2;
} else {
tmp = x / (a * t_3);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x * math.pow(z, y)) / (y * a) t_2 = x * (math.pow(a, (t + -1.0)) / y) t_3 = y * math.exp(b) tmp = 0 if b <= -5.5e+84: tmp = x / t_3 elif b <= -4.7e-299: tmp = t_1 elif b <= 4.6e-219: tmp = t_2 elif b <= 1.25e-127: tmp = t_1 elif b <= 4.4e+92: tmp = t_2 else: tmp = x / (a * t_3) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * (z ^ y)) / Float64(y * a)) t_2 = Float64(x * Float64((a ^ Float64(t + -1.0)) / y)) t_3 = Float64(y * exp(b)) tmp = 0.0 if (b <= -5.5e+84) tmp = Float64(x / t_3); elseif (b <= -4.7e-299) tmp = t_1; elseif (b <= 4.6e-219) tmp = t_2; elseif (b <= 1.25e-127) tmp = t_1; elseif (b <= 4.4e+92) tmp = t_2; else tmp = Float64(x / Float64(a * t_3)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x * (z ^ y)) / (y * a); t_2 = x * ((a ^ (t + -1.0)) / y); t_3 = y * exp(b); tmp = 0.0; if (b <= -5.5e+84) tmp = x / t_3; elseif (b <= -4.7e-299) tmp = t_1; elseif (b <= 4.6e-219) tmp = t_2; elseif (b <= 1.25e-127) tmp = t_1; elseif (b <= 4.4e+92) tmp = t_2; else tmp = x / (a * t_3); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5.5e+84], N[(x / t$95$3), $MachinePrecision], If[LessEqual[b, -4.7e-299], t$95$1, If[LessEqual[b, 4.6e-219], t$95$2, If[LessEqual[b, 1.25e-127], t$95$1, If[LessEqual[b, 4.4e+92], t$95$2, N[(x / N[(a * t$95$3), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot {z}^{y}}{y \cdot a}\\
t_2 := x \cdot \frac{{a}^{\left(t + -1\right)}}{y}\\
t_3 := y \cdot e^{b}\\
\mathbf{if}\;b \leq -5.5 \cdot 10^{+84}:\\
\;\;\;\;\frac{x}{t\_3}\\
\mathbf{elif}\;b \leq -4.7 \cdot 10^{-299}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 4.6 \cdot 10^{-219}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 1.25 \cdot 10^{-127}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 4.4 \cdot 10^{+92}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot t\_3}\\
\end{array}
\end{array}
if b < -5.5000000000000004e84Initial program 100.0%
*-commutative100.0%
associate-/l*92.9%
associate--l+92.9%
fma-define92.9%
sub-neg92.9%
metadata-eval92.9%
Simplified92.9%
Taylor expanded in b around inf 85.8%
neg-mul-185.8%
Simplified85.8%
Taylor expanded in b around inf 90.6%
exp-neg90.6%
associate-*r/90.6%
*-rgt-identity90.6%
associate-/r*90.6%
*-commutative90.6%
Simplified90.6%
if -5.5000000000000004e84 < b < -4.6999999999999997e-299 or 4.59999999999999977e-219 < b < 1.2499999999999999e-127Initial program 97.9%
associate-/l*97.2%
associate--l+97.2%
exp-sum82.1%
associate-/l*79.2%
*-commutative79.2%
exp-to-pow79.2%
exp-diff76.4%
*-commutative76.4%
exp-to-pow77.4%
sub-neg77.4%
metadata-eval77.4%
Simplified77.4%
Taylor expanded in t around 0 72.3%
Taylor expanded in b around 0 75.2%
*-commutative75.2%
Simplified75.2%
if -4.6999999999999997e-299 < b < 4.59999999999999977e-219 or 1.2499999999999999e-127 < b < 4.39999999999999984e92Initial program 95.2%
*-commutative95.2%
associate-/l*89.4%
associate--l+89.4%
fma-define89.4%
sub-neg89.4%
metadata-eval89.4%
Simplified89.4%
Taylor expanded in y around 0 80.7%
Taylor expanded in b around 0 72.5%
associate-/l*78.6%
exp-to-pow79.5%
sub-neg79.5%
metadata-eval79.5%
+-commutative79.5%
Simplified79.5%
if 4.39999999999999984e92 < b Initial program 100.0%
*-commutative100.0%
associate-/l*85.7%
associate--l+85.7%
fma-define85.7%
sub-neg85.7%
metadata-eval85.7%
Simplified85.7%
Taylor expanded in y around 0 82.9%
div-exp54.3%
exp-to-pow54.3%
sub-neg54.3%
metadata-eval54.3%
Simplified54.3%
Taylor expanded in t around 0 85.9%
Final simplification80.4%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.75e+53)
(/
(*
x
(+
(/ 1.0 a)
(*
b
(-
(/ -1.0 a)
(* b (- (* 0.5 (/ -1.0 a)) (* -0.16666666666666666 (/ b a))))))))
y)
(if (<= b -3400000000000.0)
(* x (/ (exp b) y))
(if (<= b -1.7e-35)
(/ (/ (- (* x a) (* a (* x b))) (* a a)) y)
(if (<= b 6.2e-234)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(if (<= b 22.5)
(/ -1.0 (* a (/ y (- (* x b) x))))
(/ x (* y (exp b)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.75e+53) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= -3400000000000.0) {
tmp = x * (exp(b) / y);
} else if (b <= -1.7e-35) {
tmp = (((x * a) - (a * (x * b))) / (a * a)) / y;
} else if (b <= 6.2e-234) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if (b <= 22.5) {
tmp = -1.0 / (a * (y / ((x * b) - x)));
} else {
tmp = x / (y * exp(b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.75d+53)) then
tmp = (x * ((1.0d0 / a) + (b * (((-1.0d0) / a) - (b * ((0.5d0 * ((-1.0d0) / a)) - ((-0.16666666666666666d0) * (b / a)))))))) / y
else if (b <= (-3400000000000.0d0)) then
tmp = x * (exp(b) / y)
else if (b <= (-1.7d-35)) then
tmp = (((x * a) - (a * (x * b))) / (a * a)) / y
else if (b <= 6.2d-234) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else if (b <= 22.5d0) then
tmp = (-1.0d0) / (a * (y / ((x * b) - x)))
else
tmp = x / (y * exp(b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.75e+53) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= -3400000000000.0) {
tmp = x * (Math.exp(b) / y);
} else if (b <= -1.7e-35) {
tmp = (((x * a) - (a * (x * b))) / (a * a)) / y;
} else if (b <= 6.2e-234) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if (b <= 22.5) {
tmp = -1.0 / (a * (y / ((x * b) - x)));
} else {
tmp = x / (y * Math.exp(b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.75e+53: tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y elif b <= -3400000000000.0: tmp = x * (math.exp(b) / y) elif b <= -1.7e-35: tmp = (((x * a) - (a * (x * b))) / (a * a)) / y elif b <= 6.2e-234: tmp = (b * ((x / (a * b)) - (x / a))) / y elif b <= 22.5: tmp = -1.0 / (a * (y / ((x * b) - x))) else: tmp = x / (y * math.exp(b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.75e+53) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(-1.0 / a) - Float64(b * Float64(Float64(0.5 * Float64(-1.0 / a)) - Float64(-0.16666666666666666 * Float64(b / a)))))))) / y); elseif (b <= -3400000000000.0) tmp = Float64(x * Float64(exp(b) / y)); elseif (b <= -1.7e-35) tmp = Float64(Float64(Float64(Float64(x * a) - Float64(a * Float64(x * b))) / Float64(a * a)) / y); elseif (b <= 6.2e-234) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); elseif (b <= 22.5) tmp = Float64(-1.0 / Float64(a * Float64(y / Float64(Float64(x * b) - x)))); else tmp = Float64(x / Float64(y * exp(b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.75e+53) tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y; elseif (b <= -3400000000000.0) tmp = x * (exp(b) / y); elseif (b <= -1.7e-35) tmp = (((x * a) - (a * (x * b))) / (a * a)) / y; elseif (b <= 6.2e-234) tmp = (b * ((x / (a * b)) - (x / a))) / y; elseif (b <= 22.5) tmp = -1.0 / (a * (y / ((x * b) - x))); else tmp = x / (y * exp(b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.75e+53], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(-1.0 / a), $MachinePrecision] - N[(b * N[(N[(0.5 * N[(-1.0 / a), $MachinePrecision]), $MachinePrecision] - N[(-0.16666666666666666 * N[(b / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -3400000000000.0], N[(x * N[(N[Exp[b], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.7e-35], N[(N[(N[(N[(x * a), $MachinePrecision] - N[(a * N[(x * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 6.2e-234], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 22.5], N[(-1.0 / N[(a * N[(y / N[(N[(x * b), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.75 \cdot 10^{+53}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(\frac{-1}{a} - b \cdot \left(0.5 \cdot \frac{-1}{a} - -0.16666666666666666 \cdot \frac{b}{a}\right)\right)\right)}{y}\\
\mathbf{elif}\;b \leq -3400000000000:\\
\;\;\;\;x \cdot \frac{e^{b}}{y}\\
\mathbf{elif}\;b \leq -1.7 \cdot 10^{-35}:\\
\;\;\;\;\frac{\frac{x \cdot a - a \cdot \left(x \cdot b\right)}{a \cdot a}}{y}\\
\mathbf{elif}\;b \leq 6.2 \cdot 10^{-234}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{elif}\;b \leq 22.5:\\
\;\;\;\;\frac{-1}{a \cdot \frac{y}{x \cdot b - x}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot e^{b}}\\
\end{array}
\end{array}
if b < -1.75000000000000009e53Initial program 100.0%
*-commutative100.0%
associate-/l*91.7%
associate--l+91.7%
fma-define91.7%
sub-neg91.7%
metadata-eval91.7%
Simplified91.7%
Taylor expanded in y around 0 89.7%
Taylor expanded in t around 0 87.7%
*-commutative87.7%
exp-diff87.7%
mul-1-neg87.7%
log-rec87.7%
rem-exp-log87.7%
associate-/l/87.7%
associate-/r*87.7%
exp-neg87.7%
Simplified87.7%
Taylor expanded in b around 0 87.9%
if -1.75000000000000009e53 < b < -3.4e12Initial program 100.0%
*-commutative100.0%
associate-/l*83.3%
associate--l+83.3%
fma-define83.3%
sub-neg83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in b around inf 17.7%
neg-mul-117.7%
Simplified17.7%
associate-*r/18.0%
clear-num18.0%
*-commutative18.0%
add-sqr-sqrt18.0%
sqrt-unprod18.0%
sqr-neg18.0%
sqrt-unprod0.0%
add-sqr-sqrt83.6%
Applied egg-rr83.6%
associate-/r*66.9%
associate-/r/66.9%
associate-/r/66.9%
associate-*l/66.9%
metadata-eval66.9%
distribute-lft-neg-in66.9%
neg-mul-166.9%
remove-double-neg66.9%
associate-*l/83.6%
associate-/l*83.6%
Simplified83.6%
if -3.4e12 < b < -1.7000000000000001e-35Initial program 100.0%
*-commutative100.0%
associate-/l*100.0%
associate--l+100.0%
fma-define100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around 0 73.4%
Taylor expanded in t around 0 39.0%
*-commutative39.0%
exp-diff39.0%
mul-1-neg39.0%
log-rec39.0%
rem-exp-log39.0%
associate-/l/39.0%
associate-/r*39.0%
exp-neg39.0%
Simplified39.0%
Taylor expanded in b around 0 21.9%
+-commutative21.9%
mul-1-neg21.9%
unsub-neg21.9%
*-commutative21.9%
associate-/l*21.9%
Simplified21.9%
frac-2neg21.9%
associate-*r/21.9%
*-commutative21.9%
frac-sub48.0%
Applied egg-rr48.0%
if -1.7000000000000001e-35 < b < 6.2000000000000003e-234Initial program 96.2%
*-commutative96.2%
associate-/l*83.3%
associate--l+83.3%
fma-define83.3%
sub-neg83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in y around 0 68.4%
Taylor expanded in t around 0 42.0%
*-commutative42.0%
exp-diff42.0%
mul-1-neg42.0%
log-rec42.0%
rem-exp-log43.3%
associate-/l/43.3%
associate-/r*43.3%
exp-neg43.3%
Simplified43.3%
Taylor expanded in b around 0 43.3%
+-commutative43.3%
mul-1-neg43.3%
unsub-neg43.3%
*-commutative43.3%
associate-/l*43.3%
Simplified43.3%
Taylor expanded in b around inf 49.7%
if 6.2000000000000003e-234 < b < 22.5Initial program 95.2%
*-commutative95.2%
associate-/l*92.9%
associate--l+92.9%
fma-define92.9%
sub-neg92.9%
metadata-eval92.9%
Simplified92.9%
Taylor expanded in y around 0 69.9%
Taylor expanded in t around 0 44.6%
*-commutative44.6%
exp-diff44.6%
mul-1-neg44.6%
log-rec44.6%
rem-exp-log45.9%
associate-/l/45.9%
associate-/r*45.9%
exp-neg45.9%
Simplified45.9%
Taylor expanded in b around 0 38.8%
+-commutative38.8%
mul-1-neg38.8%
unsub-neg38.8%
*-commutative38.8%
associate-/l*38.8%
Simplified38.8%
clear-num38.8%
inv-pow38.8%
associate-*r/38.8%
*-commutative38.8%
sub-div45.8%
Applied egg-rr45.8%
unpow-145.8%
associate-/r/57.5%
*-commutative57.5%
Simplified57.5%
if 22.5 < b Initial program 100.0%
*-commutative100.0%
associate-/l*91.2%
associate--l+91.2%
fma-define91.2%
sub-neg91.2%
metadata-eval91.2%
Simplified91.2%
Taylor expanded in b around inf 67.1%
neg-mul-167.1%
Simplified67.1%
Taylor expanded in b around inf 75.8%
exp-neg75.8%
associate-*r/75.8%
*-rgt-identity75.8%
associate-/r*75.8%
*-commutative75.8%
Simplified75.8%
Final simplification65.1%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -6.4e+52)
(/
(*
x
(+
(/ 1.0 a)
(*
b
(-
(/ -1.0 a)
(* b (- (* 0.5 (/ -1.0 a)) (* -0.16666666666666666 (/ b a))))))))
y)
(if (<= b 6e+85) (* x (/ (pow a (+ t -1.0)) y)) (/ x (* a (* y (exp b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -6.4e+52) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= 6e+85) {
tmp = x * (pow(a, (t + -1.0)) / y);
} else {
tmp = x / (a * (y * exp(b)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-6.4d+52)) then
tmp = (x * ((1.0d0 / a) + (b * (((-1.0d0) / a) - (b * ((0.5d0 * ((-1.0d0) / a)) - ((-0.16666666666666666d0) * (b / a)))))))) / y
else if (b <= 6d+85) then
tmp = x * ((a ** (t + (-1.0d0))) / y)
else
tmp = x / (a * (y * exp(b)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -6.4e+52) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= 6e+85) {
tmp = x * (Math.pow(a, (t + -1.0)) / y);
} else {
tmp = x / (a * (y * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -6.4e+52: tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y elif b <= 6e+85: tmp = x * (math.pow(a, (t + -1.0)) / y) else: tmp = x / (a * (y * math.exp(b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -6.4e+52) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(-1.0 / a) - Float64(b * Float64(Float64(0.5 * Float64(-1.0 / a)) - Float64(-0.16666666666666666 * Float64(b / a)))))))) / y); elseif (b <= 6e+85) tmp = Float64(x * Float64((a ^ Float64(t + -1.0)) / y)); else tmp = Float64(x / Float64(a * Float64(y * exp(b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -6.4e+52) tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y; elseif (b <= 6e+85) tmp = x * ((a ^ (t + -1.0)) / y); else tmp = x / (a * (y * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -6.4e+52], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(-1.0 / a), $MachinePrecision] - N[(b * N[(N[(0.5 * N[(-1.0 / a), $MachinePrecision]), $MachinePrecision] - N[(-0.16666666666666666 * N[(b / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 6e+85], N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6.4 \cdot 10^{+52}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(\frac{-1}{a} - b \cdot \left(0.5 \cdot \frac{-1}{a} - -0.16666666666666666 \cdot \frac{b}{a}\right)\right)\right)}{y}\\
\mathbf{elif}\;b \leq 6 \cdot 10^{+85}:\\
\;\;\;\;x \cdot \frac{{a}^{\left(t + -1\right)}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\end{array}
\end{array}
if b < -6.4e52Initial program 100.0%
*-commutative100.0%
associate-/l*91.8%
associate--l+91.8%
fma-define91.8%
sub-neg91.8%
metadata-eval91.8%
Simplified91.8%
Taylor expanded in y around 0 87.9%
Taylor expanded in t around 0 85.9%
*-commutative85.9%
exp-diff85.9%
mul-1-neg85.9%
log-rec85.9%
rem-exp-log85.9%
associate-/l/85.9%
associate-/r*85.9%
exp-neg85.9%
Simplified85.9%
Taylor expanded in b around 0 86.2%
if -6.4e52 < b < 6.0000000000000001e85Initial program 96.7%
*-commutative96.7%
associate-/l*89.6%
associate--l+89.6%
fma-define89.6%
sub-neg89.6%
metadata-eval89.6%
Simplified89.6%
Taylor expanded in y around 0 71.9%
Taylor expanded in b around 0 67.9%
associate-/l*69.5%
exp-to-pow70.5%
sub-neg70.5%
metadata-eval70.5%
+-commutative70.5%
Simplified70.5%
if 6.0000000000000001e85 < b Initial program 100.0%
*-commutative100.0%
associate-/l*85.7%
associate--l+85.7%
fma-define85.7%
sub-neg85.7%
metadata-eval85.7%
Simplified85.7%
Taylor expanded in y around 0 82.9%
div-exp54.3%
exp-to-pow54.3%
sub-neg54.3%
metadata-eval54.3%
Simplified54.3%
Taylor expanded in t around 0 85.9%
Final simplification75.6%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -2.85e+56) (not (<= t 2.5))) (/ (* x (pow a t)) y) (/ x (* a (* y (exp b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -2.85e+56) || !(t <= 2.5)) {
tmp = (x * pow(a, t)) / y;
} else {
tmp = x / (a * (y * exp(b)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((t <= (-2.85d+56)) .or. (.not. (t <= 2.5d0))) then
tmp = (x * (a ** t)) / y
else
tmp = x / (a * (y * exp(b)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -2.85e+56) || !(t <= 2.5)) {
tmp = (x * Math.pow(a, t)) / y;
} else {
tmp = x / (a * (y * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -2.85e+56) or not (t <= 2.5): tmp = (x * math.pow(a, t)) / y else: tmp = x / (a * (y * math.exp(b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -2.85e+56) || !(t <= 2.5)) tmp = Float64(Float64(x * (a ^ t)) / y); else tmp = Float64(x / Float64(a * Float64(y * exp(b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -2.85e+56) || ~((t <= 2.5))) tmp = (x * (a ^ t)) / y; else tmp = x / (a * (y * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -2.85e+56], N[Not[LessEqual[t, 2.5]], $MachinePrecision]], N[(N[(x * N[Power[a, t], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.85 \cdot 10^{+56} \lor \neg \left(t \leq 2.5\right):\\
\;\;\;\;\frac{x \cdot {a}^{t}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\end{array}
\end{array}
if t < -2.8500000000000001e56 or 2.5 < t Initial program 100.0%
*-commutative100.0%
associate-/l*88.0%
associate--l+88.0%
fma-define88.0%
sub-neg88.0%
metadata-eval88.0%
Simplified88.0%
Taylor expanded in t around inf 69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in a around 0 80.6%
if -2.8500000000000001e56 < t < 2.5Initial program 95.9%
*-commutative95.9%
associate-/l*90.7%
associate--l+90.7%
fma-define90.7%
sub-neg90.7%
metadata-eval90.7%
Simplified90.7%
Taylor expanded in y around 0 67.0%
div-exp64.9%
exp-to-pow66.2%
sub-neg66.2%
metadata-eval66.2%
Simplified66.2%
Taylor expanded in t around 0 69.6%
Final simplification74.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -5.2e-176)
(/
(*
x
(+
(/ 1.0 a)
(*
b
(-
(/ -1.0 a)
(* b (- (* 0.5 (/ -1.0 a)) (* -0.16666666666666666 (/ b a))))))))
y)
(if (<= b 2.2e-235)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(if (<= b 8500000000000.0)
(/ -1.0 (* a (/ y (- (* x b) x))))
(if (<= b 1.4e+184)
(/ (- (/ x a) (/ (* b (+ x (* x (* b -0.5)))) a)) y)
(* (/ x y) (/ 1.0 a)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -5.2e-176) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= 2.2e-235) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if (b <= 8500000000000.0) {
tmp = -1.0 / (a * (y / ((x * b) - x)));
} else if (b <= 1.4e+184) {
tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / a)) / y;
} else {
tmp = (x / y) * (1.0 / 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 <= (-5.2d-176)) then
tmp = (x * ((1.0d0 / a) + (b * (((-1.0d0) / a) - (b * ((0.5d0 * ((-1.0d0) / a)) - ((-0.16666666666666666d0) * (b / a)))))))) / y
else if (b <= 2.2d-235) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else if (b <= 8500000000000.0d0) then
tmp = (-1.0d0) / (a * (y / ((x * b) - x)))
else if (b <= 1.4d+184) then
tmp = ((x / a) - ((b * (x + (x * (b * (-0.5d0))))) / a)) / y
else
tmp = (x / y) * (1.0d0 / 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 <= -5.2e-176) {
tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y;
} else if (b <= 2.2e-235) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else if (b <= 8500000000000.0) {
tmp = -1.0 / (a * (y / ((x * b) - x)));
} else if (b <= 1.4e+184) {
tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / a)) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -5.2e-176: tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y elif b <= 2.2e-235: tmp = (b * ((x / (a * b)) - (x / a))) / y elif b <= 8500000000000.0: tmp = -1.0 / (a * (y / ((x * b) - x))) elif b <= 1.4e+184: tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / a)) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -5.2e-176) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(-1.0 / a) - Float64(b * Float64(Float64(0.5 * Float64(-1.0 / a)) - Float64(-0.16666666666666666 * Float64(b / a)))))))) / y); elseif (b <= 2.2e-235) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); elseif (b <= 8500000000000.0) tmp = Float64(-1.0 / Float64(a * Float64(y / Float64(Float64(x * b) - x)))); elseif (b <= 1.4e+184) tmp = Float64(Float64(Float64(x / a) - Float64(Float64(b * Float64(x + Float64(x * Float64(b * -0.5)))) / a)) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -5.2e-176) tmp = (x * ((1.0 / a) + (b * ((-1.0 / a) - (b * ((0.5 * (-1.0 / a)) - (-0.16666666666666666 * (b / a)))))))) / y; elseif (b <= 2.2e-235) tmp = (b * ((x / (a * b)) - (x / a))) / y; elseif (b <= 8500000000000.0) tmp = -1.0 / (a * (y / ((x * b) - x))); elseif (b <= 1.4e+184) tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / a)) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -5.2e-176], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(-1.0 / a), $MachinePrecision] - N[(b * N[(N[(0.5 * N[(-1.0 / a), $MachinePrecision]), $MachinePrecision] - N[(-0.16666666666666666 * N[(b / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2.2e-235], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 8500000000000.0], N[(-1.0 / N[(a * N[(y / N[(N[(x * b), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.4e+184], N[(N[(N[(x / a), $MachinePrecision] - N[(N[(b * N[(x + N[(x * N[(b * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -5.2 \cdot 10^{-176}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(\frac{-1}{a} - b \cdot \left(0.5 \cdot \frac{-1}{a} - -0.16666666666666666 \cdot \frac{b}{a}\right)\right)\right)}{y}\\
\mathbf{elif}\;b \leq 2.2 \cdot 10^{-235}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{elif}\;b \leq 8500000000000:\\
\;\;\;\;\frac{-1}{a \cdot \frac{y}{x \cdot b - x}}\\
\mathbf{elif}\;b \leq 1.4 \cdot 10^{+184}:\\
\;\;\;\;\frac{\frac{x}{a} - \frac{b \cdot \left(x + x \cdot \left(b \cdot -0.5\right)\right)}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < -5.19999999999999984e-176Initial program 99.4%
*-commutative99.4%
associate-/l*90.8%
associate--l+90.8%
fma-define90.8%
sub-neg90.8%
metadata-eval90.8%
Simplified90.8%
Taylor expanded in y around 0 78.4%
Taylor expanded in t around 0 64.4%
*-commutative64.4%
exp-diff64.4%
mul-1-neg64.4%
log-rec64.4%
rem-exp-log65.0%
associate-/l/65.0%
associate-/r*65.0%
exp-neg65.0%
Simplified65.0%
Taylor expanded in b around 0 62.4%
if -5.19999999999999984e-176 < b < 2.19999999999999984e-235Initial program 94.1%
*-commutative94.1%
associate-/l*78.6%
associate--l+78.6%
fma-define78.6%
sub-neg78.6%
metadata-eval78.6%
Simplified78.6%
Taylor expanded in y around 0 69.4%
Taylor expanded in t around 0 34.5%
*-commutative34.5%
exp-diff34.5%
mul-1-neg34.5%
log-rec34.5%
rem-exp-log35.5%
associate-/l/35.5%
associate-/r*35.5%
exp-neg35.5%
Simplified35.5%
Taylor expanded in b around 0 35.5%
+-commutative35.5%
mul-1-neg35.5%
unsub-neg35.5%
*-commutative35.5%
associate-/l*35.5%
Simplified35.5%
Taylor expanded in b around inf 52.7%
if 2.19999999999999984e-235 < b < 8.5e12Initial program 95.4%
*-commutative95.4%
associate-/l*93.2%
associate--l+93.2%
fma-define93.2%
sub-neg93.2%
metadata-eval93.2%
Simplified93.2%
Taylor expanded in y around 0 70.9%
Taylor expanded in t around 0 46.4%
*-commutative46.4%
exp-diff46.5%
mul-1-neg46.5%
log-rec46.5%
rem-exp-log47.7%
associate-/l/47.7%
associate-/r*47.7%
exp-neg47.7%
Simplified47.7%
Taylor expanded in b around 0 37.5%
+-commutative37.5%
mul-1-neg37.5%
unsub-neg37.5%
*-commutative37.5%
associate-/l*37.5%
Simplified37.5%
clear-num37.5%
inv-pow37.5%
associate-*r/37.5%
*-commutative37.5%
sub-div44.4%
Applied egg-rr44.4%
unpow-144.4%
associate-/r/55.6%
*-commutative55.6%
Simplified55.6%
if 8.5e12 < b < 1.39999999999999995e184Initial program 100.0%
*-commutative100.0%
associate-/l*100.0%
associate--l+100.0%
fma-define100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around 0 87.7%
Taylor expanded in t around 0 60.0%
*-commutative60.0%
exp-diff60.0%
mul-1-neg60.0%
log-rec60.0%
rem-exp-log60.0%
associate-/l/60.0%
associate-/r*60.0%
exp-neg60.0%
Simplified60.0%
Taylor expanded in b around 0 39.1%
Taylor expanded in a around -inf 42.2%
mul-1-neg42.2%
associate-*r*42.2%
Simplified42.2%
if 1.39999999999999995e184 < b Initial program 100.0%
*-commutative100.0%
associate-/l*78.3%
associate--l+78.3%
fma-define78.3%
sub-neg78.3%
metadata-eval78.3%
Simplified78.3%
Taylor expanded in y around 0 100.0%
Taylor expanded in t around 0 95.7%
*-commutative95.7%
exp-diff95.7%
mul-1-neg95.7%
log-rec95.7%
rem-exp-log95.7%
associate-/l/95.7%
associate-/r*95.7%
exp-neg95.7%
Simplified95.7%
Taylor expanded in b around 0 19.4%
*-commutative19.4%
Simplified19.4%
*-un-lft-identity19.4%
*-commutative19.4%
times-frac23.5%
Applied egg-rr23.5%
Final simplification53.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* y a))))
(if (<= a 4.5e+36)
(/ (* x (+ (/ 1.0 a) (* b (+ (* (/ b a) 0.5) (/ -1.0 a))))) y)
(if (<= a 3.3e+261)
(- t_1 (* b (- t_1 (* 0.5 (/ (* x b) (* y a))))))
(/ (- (/ x a) (/ (* b (+ x (* x (* b -0.5)))) a)) y)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y * a);
double tmp;
if (a <= 4.5e+36) {
tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y;
} else if (a <= 3.3e+261) {
tmp = t_1 - (b * (t_1 - (0.5 * ((x * b) / (y * a)))));
} else {
tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / 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) :: t_1
real(8) :: tmp
t_1 = x / (y * a)
if (a <= 4.5d+36) then
tmp = (x * ((1.0d0 / a) + (b * (((b / a) * 0.5d0) + ((-1.0d0) / a))))) / y
else if (a <= 3.3d+261) then
tmp = t_1 - (b * (t_1 - (0.5d0 * ((x * b) / (y * a)))))
else
tmp = ((x / a) - ((b * (x + (x * (b * (-0.5d0))))) / 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 t_1 = x / (y * a);
double tmp;
if (a <= 4.5e+36) {
tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y;
} else if (a <= 3.3e+261) {
tmp = t_1 - (b * (t_1 - (0.5 * ((x * b) / (y * a)))));
} else {
tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / a)) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (y * a) tmp = 0 if a <= 4.5e+36: tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y elif a <= 3.3e+261: tmp = t_1 - (b * (t_1 - (0.5 * ((x * b) / (y * a))))) else: tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / a)) / y return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y * a)) tmp = 0.0 if (a <= 4.5e+36) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(Float64(b / a) * 0.5) + Float64(-1.0 / a))))) / y); elseif (a <= 3.3e+261) tmp = Float64(t_1 - Float64(b * Float64(t_1 - Float64(0.5 * Float64(Float64(x * b) / Float64(y * a)))))); else tmp = Float64(Float64(Float64(x / a) - Float64(Float64(b * Float64(x + Float64(x * Float64(b * -0.5)))) / a)) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (y * a); tmp = 0.0; if (a <= 4.5e+36) tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y; elseif (a <= 3.3e+261) tmp = t_1 - (b * (t_1 - (0.5 * ((x * b) / (y * a))))); else tmp = ((x / a) - ((b * (x + (x * (b * -0.5)))) / a)) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, 4.5e+36], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(N[(b / a), $MachinePrecision] * 0.5), $MachinePrecision] + N[(-1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[a, 3.3e+261], N[(t$95$1 - N[(b * N[(t$95$1 - N[(0.5 * N[(N[(x * b), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x / a), $MachinePrecision] - N[(N[(b * N[(x + N[(x * N[(b * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y \cdot a}\\
\mathbf{if}\;a \leq 4.5 \cdot 10^{+36}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(\frac{b}{a} \cdot 0.5 + \frac{-1}{a}\right)\right)}{y}\\
\mathbf{elif}\;a \leq 3.3 \cdot 10^{+261}:\\
\;\;\;\;t\_1 - b \cdot \left(t\_1 - 0.5 \cdot \frac{x \cdot b}{y \cdot a}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{a} - \frac{b \cdot \left(x + x \cdot \left(b \cdot -0.5\right)\right)}{a}}{y}\\
\end{array}
\end{array}
if a < 4.49999999999999997e36Initial program 99.2%
*-commutative99.2%
associate-/l*90.0%
associate--l+90.0%
fma-define90.0%
sub-neg90.0%
metadata-eval90.0%
Simplified90.0%
Taylor expanded in y around 0 80.8%
Taylor expanded in t around 0 58.0%
*-commutative58.0%
exp-diff58.0%
mul-1-neg58.0%
log-rec58.0%
rem-exp-log58.7%
associate-/l/58.7%
associate-/r*58.7%
exp-neg58.7%
Simplified58.7%
Taylor expanded in b around 0 45.4%
if 4.49999999999999997e36 < a < 3.3e261Initial program 95.6%
*-commutative95.6%
associate-/l*90.3%
associate--l+90.3%
fma-define90.3%
sub-neg90.3%
metadata-eval90.3%
Simplified90.3%
Taylor expanded in y around 0 75.7%
Taylor expanded in t around 0 60.8%
*-commutative60.8%
exp-diff60.8%
mul-1-neg60.8%
log-rec60.8%
rem-exp-log61.5%
associate-/l/61.5%
associate-/r*61.5%
exp-neg61.5%
Simplified61.5%
Taylor expanded in b around 0 50.6%
if 3.3e261 < a Initial program 95.9%
*-commutative95.9%
associate-/l*83.7%
associate--l+83.7%
fma-define83.7%
sub-neg83.7%
metadata-eval83.7%
Simplified83.7%
Taylor expanded in y around 0 72.3%
Taylor expanded in t around 0 49.1%
*-commutative49.1%
exp-diff49.1%
mul-1-neg49.1%
log-rec49.1%
rem-exp-log49.2%
associate-/l/49.2%
associate-/r*49.2%
exp-neg49.2%
Simplified49.2%
Taylor expanded in b around 0 49.8%
Taylor expanded in a around -inf 65.0%
mul-1-neg65.0%
associate-*r*65.0%
Simplified65.0%
Final simplification48.9%
(FPCore (x y z t a b) :precision binary64 (if (<= a 2e-18) (/ (* x (+ (/ 1.0 a) (* b (+ (* (/ b a) 0.5) (/ -1.0 a))))) y) (/ (+ x (* b (- (* 0.5 (* x b)) x))) (* y a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 2e-18) {
tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y;
} else {
tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= 2d-18) then
tmp = (x * ((1.0d0 / a) + (b * (((b / a) * 0.5d0) + ((-1.0d0) / a))))) / y
else
tmp = (x + (b * ((0.5d0 * (x * b)) - x))) / (y * a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 2e-18) {
tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y;
} else {
tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 2e-18: tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y else: tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 2e-18) tmp = Float64(Float64(x * Float64(Float64(1.0 / a) + Float64(b * Float64(Float64(Float64(b / a) * 0.5) + Float64(-1.0 / a))))) / y); else tmp = Float64(Float64(x + Float64(b * Float64(Float64(0.5 * Float64(x * b)) - x))) / Float64(y * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 2e-18) tmp = (x * ((1.0 / a) + (b * (((b / a) * 0.5) + (-1.0 / a))))) / y; else tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 2e-18], N[(N[(x * N[(N[(1.0 / a), $MachinePrecision] + N[(b * N[(N[(N[(b / a), $MachinePrecision] * 0.5), $MachinePrecision] + N[(-1.0 / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x + N[(b * N[(N[(0.5 * N[(x * b), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 2 \cdot 10^{-18}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{a} + b \cdot \left(\frac{b}{a} \cdot 0.5 + \frac{-1}{a}\right)\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x + b \cdot \left(0.5 \cdot \left(x \cdot b\right) - x\right)}{y \cdot a}\\
\end{array}
\end{array}
if a < 2.0000000000000001e-18Initial program 99.2%
*-commutative99.2%
associate-/l*89.1%
associate--l+89.1%
fma-define89.1%
sub-neg89.1%
metadata-eval89.1%
Simplified89.1%
Taylor expanded in y around 0 81.0%
Taylor expanded in t around 0 57.3%
*-commutative57.3%
exp-diff57.3%
mul-1-neg57.3%
log-rec57.3%
rem-exp-log58.0%
associate-/l/58.0%
associate-/r*58.1%
exp-neg58.1%
Simplified58.1%
Taylor expanded in b around 0 45.5%
if 2.0000000000000001e-18 < a Initial program 96.1%
*-commutative96.1%
associate-/l*90.0%
associate--l+90.0%
fma-define90.0%
sub-neg90.0%
metadata-eval90.0%
Simplified90.0%
Taylor expanded in y around 0 75.3%
Taylor expanded in t around 0 58.8%
*-commutative58.8%
exp-diff58.8%
mul-1-neg58.8%
log-rec58.8%
rem-exp-log59.4%
associate-/l/59.4%
associate-/r*59.4%
exp-neg59.4%
Simplified59.4%
Taylor expanded in b around 0 42.2%
Taylor expanded in a around 0 49.5%
Final simplification47.3%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.75e+145)
(- (/ x y) (/ (* x b) y))
(if (<= b 9e-236)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(* (/ x y) (/ 1.0 a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.75e+145) {
tmp = (x / y) - ((x * b) / y);
} else if (b <= 9e-236) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / 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.75d+145)) then
tmp = (x / y) - ((x * b) / y)
else if (b <= 9d-236) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else
tmp = (x / y) * (1.0d0 / 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.75e+145) {
tmp = (x / y) - ((x * b) / y);
} else if (b <= 9e-236) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.75e+145: tmp = (x / y) - ((x * b) / y) elif b <= 9e-236: tmp = (b * ((x / (a * b)) - (x / a))) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.75e+145) tmp = Float64(Float64(x / y) - Float64(Float64(x * b) / y)); elseif (b <= 9e-236) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.75e+145) tmp = (x / y) - ((x * b) / y); elseif (b <= 9e-236) tmp = (b * ((x / (a * b)) - (x / a))) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.75e+145], N[(N[(x / y), $MachinePrecision] - N[(N[(x * b), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9e-236], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.75 \cdot 10^{+145}:\\
\;\;\;\;\frac{x}{y} - \frac{x \cdot b}{y}\\
\mathbf{elif}\;b \leq 9 \cdot 10^{-236}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < -1.7500000000000001e145Initial program 100.0%
*-commutative100.0%
associate-/l*90.0%
associate--l+90.0%
fma-define90.0%
sub-neg90.0%
metadata-eval90.0%
Simplified90.0%
Taylor expanded in b around inf 83.4%
neg-mul-183.4%
Simplified83.4%
Taylor expanded in b around 0 58.4%
if -1.7500000000000001e145 < b < 8.99999999999999997e-236Initial program 97.4%
*-commutative97.4%
associate-/l*86.7%
associate--l+86.7%
fma-define86.7%
sub-neg86.7%
metadata-eval86.7%
Simplified86.7%
Taylor expanded in y around 0 71.3%
Taylor expanded in t around 0 47.1%
*-commutative47.1%
exp-diff47.1%
mul-1-neg47.1%
log-rec47.1%
rem-exp-log48.0%
associate-/l/48.0%
associate-/r*48.0%
exp-neg48.0%
Simplified48.0%
Taylor expanded in b around 0 41.3%
+-commutative41.3%
mul-1-neg41.3%
unsub-neg41.3%
*-commutative41.3%
associate-/l*41.4%
Simplified41.4%
Taylor expanded in b around inf 45.7%
if 8.99999999999999997e-236 < b Initial program 97.6%
*-commutative97.6%
associate-/l*92.1%
associate--l+92.1%
fma-define92.1%
sub-neg92.1%
metadata-eval92.1%
Simplified92.1%
Taylor expanded in y around 0 81.5%
Taylor expanded in t around 0 60.2%
*-commutative60.2%
exp-diff60.2%
mul-1-neg60.2%
log-rec60.2%
rem-exp-log60.9%
associate-/l/60.9%
associate-/r*60.9%
exp-neg60.9%
Simplified60.9%
Taylor expanded in b around 0 37.7%
*-commutative37.7%
Simplified37.7%
*-un-lft-identity37.7%
*-commutative37.7%
times-frac41.8%
Applied egg-rr41.8%
Final simplification45.5%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -5.2e-176)
(/ (+ (/ x a) (* b (* 0.5 (/ (* x b) a)))) y)
(if (<= b 1.55e-234)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(* (/ x y) (/ 1.0 a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -5.2e-176) {
tmp = ((x / a) + (b * (0.5 * ((x * b) / a)))) / y;
} else if (b <= 1.55e-234) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / 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 <= (-5.2d-176)) then
tmp = ((x / a) + (b * (0.5d0 * ((x * b) / a)))) / y
else if (b <= 1.55d-234) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else
tmp = (x / y) * (1.0d0 / 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 <= -5.2e-176) {
tmp = ((x / a) + (b * (0.5 * ((x * b) / a)))) / y;
} else if (b <= 1.55e-234) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -5.2e-176: tmp = ((x / a) + (b * (0.5 * ((x * b) / a)))) / y elif b <= 1.55e-234: tmp = (b * ((x / (a * b)) - (x / a))) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -5.2e-176) tmp = Float64(Float64(Float64(x / a) + Float64(b * Float64(0.5 * Float64(Float64(x * b) / a)))) / y); elseif (b <= 1.55e-234) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -5.2e-176) tmp = ((x / a) + (b * (0.5 * ((x * b) / a)))) / y; elseif (b <= 1.55e-234) tmp = (b * ((x / (a * b)) - (x / a))) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -5.2e-176], N[(N[(N[(x / a), $MachinePrecision] + N[(b * N[(0.5 * N[(N[(x * b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 1.55e-234], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -5.2 \cdot 10^{-176}:\\
\;\;\;\;\frac{\frac{x}{a} + b \cdot \left(0.5 \cdot \frac{x \cdot b}{a}\right)}{y}\\
\mathbf{elif}\;b \leq 1.55 \cdot 10^{-234}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < -5.19999999999999984e-176Initial program 99.4%
*-commutative99.4%
associate-/l*90.8%
associate--l+90.8%
fma-define90.8%
sub-neg90.8%
metadata-eval90.8%
Simplified90.8%
Taylor expanded in y around 0 78.4%
Taylor expanded in t around 0 64.4%
*-commutative64.4%
exp-diff64.4%
mul-1-neg64.4%
log-rec64.4%
rem-exp-log65.0%
associate-/l/65.0%
associate-/r*65.0%
exp-neg65.0%
Simplified65.0%
Taylor expanded in b around 0 53.3%
Taylor expanded in b around inf 53.3%
if -5.19999999999999984e-176 < b < 1.5500000000000001e-234Initial program 94.1%
*-commutative94.1%
associate-/l*78.6%
associate--l+78.6%
fma-define78.6%
sub-neg78.6%
metadata-eval78.6%
Simplified78.6%
Taylor expanded in y around 0 69.4%
Taylor expanded in t around 0 34.5%
*-commutative34.5%
exp-diff34.5%
mul-1-neg34.5%
log-rec34.5%
rem-exp-log35.5%
associate-/l/35.5%
associate-/r*35.5%
exp-neg35.5%
Simplified35.5%
Taylor expanded in b around 0 35.5%
+-commutative35.5%
mul-1-neg35.5%
unsub-neg35.5%
*-commutative35.5%
associate-/l*35.5%
Simplified35.5%
Taylor expanded in b around inf 52.7%
if 1.5500000000000001e-234 < b Initial program 97.6%
*-commutative97.6%
associate-/l*92.1%
associate--l+92.1%
fma-define92.1%
sub-neg92.1%
metadata-eval92.1%
Simplified92.1%
Taylor expanded in y around 0 81.5%
Taylor expanded in t around 0 60.2%
*-commutative60.2%
exp-diff60.2%
mul-1-neg60.2%
log-rec60.2%
rem-exp-log60.9%
associate-/l/60.9%
associate-/r*60.9%
exp-neg60.9%
Simplified60.9%
Taylor expanded in b around 0 37.7%
*-commutative37.7%
Simplified37.7%
*-un-lft-identity37.7%
*-commutative37.7%
times-frac41.8%
Applied egg-rr41.8%
Final simplification48.1%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -4.7e-176)
(/ (+ (/ x a) (* b (* x (* (/ b a) 0.5)))) y)
(if (<= b 3.8e-233)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(* (/ x y) (/ 1.0 a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -4.7e-176) {
tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y;
} else if (b <= 3.8e-233) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / 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 <= (-4.7d-176)) then
tmp = ((x / a) + (b * (x * ((b / a) * 0.5d0)))) / y
else if (b <= 3.8d-233) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else
tmp = (x / y) * (1.0d0 / 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 <= -4.7e-176) {
tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y;
} else if (b <= 3.8e-233) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -4.7e-176: tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y elif b <= 3.8e-233: tmp = (b * ((x / (a * b)) - (x / a))) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -4.7e-176) tmp = Float64(Float64(Float64(x / a) + Float64(b * Float64(x * Float64(Float64(b / a) * 0.5)))) / y); elseif (b <= 3.8e-233) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -4.7e-176) tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y; elseif (b <= 3.8e-233) tmp = (b * ((x / (a * b)) - (x / a))) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -4.7e-176], N[(N[(N[(x / a), $MachinePrecision] + N[(b * N[(x * N[(N[(b / a), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 3.8e-233], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4.7 \cdot 10^{-176}:\\
\;\;\;\;\frac{\frac{x}{a} + b \cdot \left(x \cdot \left(\frac{b}{a} \cdot 0.5\right)\right)}{y}\\
\mathbf{elif}\;b \leq 3.8 \cdot 10^{-233}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < -4.69999999999999984e-176Initial program 99.4%
*-commutative99.4%
associate-/l*90.8%
associate--l+90.8%
fma-define90.8%
sub-neg90.8%
metadata-eval90.8%
Simplified90.8%
Taylor expanded in y around 0 78.4%
Taylor expanded in t around 0 64.4%
*-commutative64.4%
exp-diff64.4%
mul-1-neg64.4%
log-rec64.4%
rem-exp-log65.0%
associate-/l/65.0%
associate-/r*65.0%
exp-neg65.0%
Simplified65.0%
Taylor expanded in b around 0 53.3%
Taylor expanded in b around inf 53.3%
associate-*l/54.2%
*-commutative54.2%
*-commutative54.2%
associate-*l*54.2%
*-commutative54.2%
Simplified54.2%
if -4.69999999999999984e-176 < b < 3.8e-233Initial program 94.1%
*-commutative94.1%
associate-/l*78.6%
associate--l+78.6%
fma-define78.6%
sub-neg78.6%
metadata-eval78.6%
Simplified78.6%
Taylor expanded in y around 0 69.4%
Taylor expanded in t around 0 34.5%
*-commutative34.5%
exp-diff34.5%
mul-1-neg34.5%
log-rec34.5%
rem-exp-log35.5%
associate-/l/35.5%
associate-/r*35.5%
exp-neg35.5%
Simplified35.5%
Taylor expanded in b around 0 35.5%
+-commutative35.5%
mul-1-neg35.5%
unsub-neg35.5%
*-commutative35.5%
associate-/l*35.5%
Simplified35.5%
Taylor expanded in b around inf 52.7%
if 3.8e-233 < b Initial program 97.6%
*-commutative97.6%
associate-/l*92.1%
associate--l+92.1%
fma-define92.1%
sub-neg92.1%
metadata-eval92.1%
Simplified92.1%
Taylor expanded in y around 0 81.5%
Taylor expanded in t around 0 60.2%
*-commutative60.2%
exp-diff60.2%
mul-1-neg60.2%
log-rec60.2%
rem-exp-log60.9%
associate-/l/60.9%
associate-/r*60.9%
exp-neg60.9%
Simplified60.9%
Taylor expanded in b around 0 37.7%
*-commutative37.7%
Simplified37.7%
*-un-lft-identity37.7%
*-commutative37.7%
times-frac41.8%
Applied egg-rr41.8%
Final simplification48.5%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -9.5e+94)
(* x (- (/ 1.0 y) (* b (- (/ 1.0 y) (* 0.5 (/ b y))))))
(if (<= b 1.05e-232)
(/ (* b (- (/ x (* a b)) (/ x a))) y)
(* (/ x y) (/ 1.0 a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -9.5e+94) {
tmp = x * ((1.0 / y) - (b * ((1.0 / y) - (0.5 * (b / y)))));
} else if (b <= 1.05e-232) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / 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 <= (-9.5d+94)) then
tmp = x * ((1.0d0 / y) - (b * ((1.0d0 / y) - (0.5d0 * (b / y)))))
else if (b <= 1.05d-232) then
tmp = (b * ((x / (a * b)) - (x / a))) / y
else
tmp = (x / y) * (1.0d0 / 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 <= -9.5e+94) {
tmp = x * ((1.0 / y) - (b * ((1.0 / y) - (0.5 * (b / y)))));
} else if (b <= 1.05e-232) {
tmp = (b * ((x / (a * b)) - (x / a))) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -9.5e+94: tmp = x * ((1.0 / y) - (b * ((1.0 / y) - (0.5 * (b / y))))) elif b <= 1.05e-232: tmp = (b * ((x / (a * b)) - (x / a))) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -9.5e+94) tmp = Float64(x * Float64(Float64(1.0 / y) - Float64(b * Float64(Float64(1.0 / y) - Float64(0.5 * Float64(b / y)))))); elseif (b <= 1.05e-232) tmp = Float64(Float64(b * Float64(Float64(x / Float64(a * b)) - Float64(x / a))) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -9.5e+94) tmp = x * ((1.0 / y) - (b * ((1.0 / y) - (0.5 * (b / y))))); elseif (b <= 1.05e-232) tmp = (b * ((x / (a * b)) - (x / a))) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -9.5e+94], N[(x * N[(N[(1.0 / y), $MachinePrecision] - N[(b * N[(N[(1.0 / y), $MachinePrecision] - N[(0.5 * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.05e-232], N[(N[(b * N[(N[(x / N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(x / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{+94}:\\
\;\;\;\;x \cdot \left(\frac{1}{y} - b \cdot \left(\frac{1}{y} - 0.5 \cdot \frac{b}{y}\right)\right)\\
\mathbf{elif}\;b \leq 1.05 \cdot 10^{-232}:\\
\;\;\;\;\frac{b \cdot \left(\frac{x}{a \cdot b} - \frac{x}{a}\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < -9.4999999999999998e94Initial program 100.0%
*-commutative100.0%
associate-/l*92.7%
associate--l+92.7%
fma-define92.7%
sub-neg92.7%
metadata-eval92.7%
Simplified92.7%
Taylor expanded in b around inf 85.5%
neg-mul-185.5%
Simplified85.5%
Taylor expanded in b around inf 90.4%
associate-/l*90.4%
Simplified90.4%
Taylor expanded in b around 0 81.3%
if -9.4999999999999998e94 < b < 1.05e-232Initial program 97.1%
*-commutative97.1%
associate-/l*85.3%
associate--l+85.3%
fma-define85.3%
sub-neg85.3%
metadata-eval85.3%
Simplified85.3%
Taylor expanded in y around 0 69.1%
Taylor expanded in t around 0 42.3%
*-commutative42.3%
exp-diff42.3%
mul-1-neg42.3%
log-rec42.3%
rem-exp-log43.3%
associate-/l/43.3%
associate-/r*43.3%
exp-neg43.3%
Simplified43.3%
Taylor expanded in b around 0 39.7%
+-commutative39.7%
mul-1-neg39.7%
unsub-neg39.7%
*-commutative39.7%
associate-/l*39.7%
Simplified39.7%
Taylor expanded in b around inf 44.5%
if 1.05e-232 < b Initial program 97.6%
*-commutative97.6%
associate-/l*92.1%
associate--l+92.1%
fma-define92.1%
sub-neg92.1%
metadata-eval92.1%
Simplified92.1%
Taylor expanded in y around 0 81.5%
Taylor expanded in t around 0 60.2%
*-commutative60.2%
exp-diff60.2%
mul-1-neg60.2%
log-rec60.2%
rem-exp-log60.9%
associate-/l/60.9%
associate-/r*60.9%
exp-neg60.9%
Simplified60.9%
Taylor expanded in b around 0 37.7%
*-commutative37.7%
Simplified37.7%
*-un-lft-identity37.7%
*-commutative37.7%
times-frac41.8%
Applied egg-rr41.8%
Final simplification49.2%
(FPCore (x y z t a b) :precision binary64 (if (<= a 1.15e-87) (/ (+ (/ x a) (* b (* x (* (/ b a) 0.5)))) y) (/ (+ x (* b (- (* 0.5 (* x b)) x))) (* y a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1.15e-87) {
tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y;
} else {
tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= 1.15d-87) then
tmp = ((x / a) + (b * (x * ((b / a) * 0.5d0)))) / y
else
tmp = (x + (b * ((0.5d0 * (x * b)) - x))) / (y * a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1.15e-87) {
tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y;
} else {
tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 1.15e-87: tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y else: tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 1.15e-87) tmp = Float64(Float64(Float64(x / a) + Float64(b * Float64(x * Float64(Float64(b / a) * 0.5)))) / y); else tmp = Float64(Float64(x + Float64(b * Float64(Float64(0.5 * Float64(x * b)) - x))) / Float64(y * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 1.15e-87) tmp = ((x / a) + (b * (x * ((b / a) * 0.5)))) / y; else tmp = (x + (b * ((0.5 * (x * b)) - x))) / (y * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 1.15e-87], N[(N[(N[(x / a), $MachinePrecision] + N[(b * N[(x * N[(N[(b / a), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x + N[(b * N[(N[(0.5 * N[(x * b), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.15 \cdot 10^{-87}:\\
\;\;\;\;\frac{\frac{x}{a} + b \cdot \left(x \cdot \left(\frac{b}{a} \cdot 0.5\right)\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x + b \cdot \left(0.5 \cdot \left(x \cdot b\right) - x\right)}{y \cdot a}\\
\end{array}
\end{array}
if a < 1.1500000000000001e-87Initial program 99.2%
*-commutative99.2%
associate-/l*89.9%
associate--l+89.9%
fma-define89.9%
sub-neg89.9%
metadata-eval89.9%
Simplified89.9%
Taylor expanded in y around 0 82.9%
Taylor expanded in t around 0 60.1%
*-commutative60.1%
exp-diff60.1%
mul-1-neg60.1%
log-rec60.1%
rem-exp-log60.9%
associate-/l/60.9%
associate-/r*60.9%
exp-neg60.9%
Simplified60.9%
Taylor expanded in b around 0 38.8%
Taylor expanded in b around inf 43.6%
associate-*l/44.5%
*-commutative44.5%
*-commutative44.5%
associate-*l*44.5%
*-commutative44.5%
Simplified44.5%
if 1.1500000000000001e-87 < a Initial program 96.8%
*-commutative96.8%
associate-/l*89.2%
associate--l+89.2%
fma-define89.2%
sub-neg89.2%
metadata-eval89.2%
Simplified89.2%
Taylor expanded in y around 0 75.2%
Taylor expanded in t around 0 56.4%
*-commutative56.4%
exp-diff56.4%
mul-1-neg56.4%
log-rec56.4%
rem-exp-log57.1%
associate-/l/57.1%
associate-/r*57.1%
exp-neg57.1%
Simplified57.1%
Taylor expanded in b around 0 41.0%
Taylor expanded in a around 0 47.4%
Final simplification46.2%
(FPCore (x y z t a b) :precision binary64 (if (<= b -3.6e+53) (/ (* x (/ b (- a))) y) (if (<= b 6.4e-232) (/ (/ x a) y) (* (/ x y) (/ 1.0 a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -3.6e+53) {
tmp = (x * (b / -a)) / y;
} else if (b <= 6.4e-232) {
tmp = (x / a) / y;
} else {
tmp = (x / y) * (1.0 / 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 <= (-3.6d+53)) then
tmp = (x * (b / -a)) / y
else if (b <= 6.4d-232) then
tmp = (x / a) / y
else
tmp = (x / y) * (1.0d0 / 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 <= -3.6e+53) {
tmp = (x * (b / -a)) / y;
} else if (b <= 6.4e-232) {
tmp = (x / a) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -3.6e+53: tmp = (x * (b / -a)) / y elif b <= 6.4e-232: tmp = (x / a) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -3.6e+53) tmp = Float64(Float64(x * Float64(b / Float64(-a))) / y); elseif (b <= 6.4e-232) tmp = Float64(Float64(x / a) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -3.6e+53) tmp = (x * (b / -a)) / y; elseif (b <= 6.4e-232) tmp = (x / a) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -3.6e+53], N[(N[(x * N[(b / (-a)), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 6.4e-232], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.6 \cdot 10^{+53}:\\
\;\;\;\;\frac{x \cdot \frac{b}{-a}}{y}\\
\mathbf{elif}\;b \leq 6.4 \cdot 10^{-232}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < -3.6e53Initial program 100.0%
*-commutative100.0%
associate-/l*91.5%
associate--l+91.5%
fma-define91.5%
sub-neg91.5%
metadata-eval91.5%
Simplified91.5%
Taylor expanded in y around 0 89.5%
Taylor expanded in t around 0 87.4%
*-commutative87.4%
exp-diff87.4%
mul-1-neg87.4%
log-rec87.4%
rem-exp-log87.4%
associate-/l/87.4%
associate-/r*87.4%
exp-neg87.4%
Simplified87.4%
Taylor expanded in b around 0 49.1%
+-commutative49.1%
mul-1-neg49.1%
unsub-neg49.1%
*-commutative49.1%
associate-/l*49.1%
Simplified49.1%
Taylor expanded in b around inf 49.1%
mul-1-neg49.1%
associate-*l/49.1%
distribute-rgt-neg-in49.1%
Simplified49.1%
if -3.6e53 < b < 6.39999999999999973e-232Initial program 96.9%
*-commutative96.9%
associate-/l*85.6%
associate--l+85.6%
fma-define85.6%
sub-neg85.6%
metadata-eval85.6%
Simplified85.6%
Taylor expanded in y around 0 69.5%
Taylor expanded in t around 0 41.3%
*-commutative41.3%
exp-diff41.3%
mul-1-neg41.3%
log-rec41.3%
rem-exp-log42.4%
associate-/l/42.4%
associate-/r*42.4%
exp-neg42.4%
Simplified42.4%
Taylor expanded in b around 0 39.7%
if 6.39999999999999973e-232 < b Initial program 97.6%
*-commutative97.6%
associate-/l*92.0%
associate--l+92.0%
fma-define92.0%
sub-neg92.0%
metadata-eval92.0%
Simplified92.0%
Taylor expanded in y around 0 81.3%
Taylor expanded in t around 0 59.8%
*-commutative59.8%
exp-diff59.9%
mul-1-neg59.9%
log-rec59.9%
rem-exp-log60.5%
associate-/l/60.5%
associate-/r*60.5%
exp-neg60.5%
Simplified60.5%
Taylor expanded in b around 0 38.0%
*-commutative38.0%
Simplified38.0%
*-un-lft-identity38.0%
*-commutative38.0%
times-frac42.2%
Applied egg-rr42.2%
Final simplification42.5%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.05e+99) (* x (- (/ 1.0 y) (/ b y))) (if (<= b 9.6e-232) (/ (/ x a) y) (* (/ x y) (/ 1.0 a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.05e+99) {
tmp = x * ((1.0 / y) - (b / y));
} else if (b <= 9.6e-232) {
tmp = (x / a) / y;
} else {
tmp = (x / y) * (1.0 / 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.05d+99)) then
tmp = x * ((1.0d0 / y) - (b / y))
else if (b <= 9.6d-232) then
tmp = (x / a) / y
else
tmp = (x / y) * (1.0d0 / 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.05e+99) {
tmp = x * ((1.0 / y) - (b / y));
} else if (b <= 9.6e-232) {
tmp = (x / a) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.05e+99: tmp = x * ((1.0 / y) - (b / y)) elif b <= 9.6e-232: tmp = (x / a) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.05e+99) tmp = Float64(x * Float64(Float64(1.0 / y) - Float64(b / y))); elseif (b <= 9.6e-232) tmp = Float64(Float64(x / a) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.05e+99) tmp = x * ((1.0 / y) - (b / y)); elseif (b <= 9.6e-232) tmp = (x / a) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.05e+99], N[(x * N[(N[(1.0 / y), $MachinePrecision] - N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.6e-232], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.05 \cdot 10^{+99}:\\
\;\;\;\;x \cdot \left(\frac{1}{y} - \frac{b}{y}\right)\\
\mathbf{elif}\;b \leq 9.6 \cdot 10^{-232}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < -1.05000000000000005e99Initial program 100.0%
*-commutative100.0%
associate-/l*92.7%
associate--l+92.7%
fma-define92.7%
sub-neg92.7%
metadata-eval92.7%
Simplified92.7%
Taylor expanded in b around inf 85.5%
neg-mul-185.5%
Simplified85.5%
Taylor expanded in b around inf 90.4%
associate-/l*90.4%
Simplified90.4%
Taylor expanded in b around 0 55.5%
+-commutative55.5%
mul-1-neg55.5%
unsub-neg55.5%
Simplified55.5%
if -1.05000000000000005e99 < b < 9.59999999999999995e-232Initial program 97.1%
*-commutative97.1%
associate-/l*85.4%
associate--l+85.4%
fma-define85.4%
sub-neg85.4%
metadata-eval85.4%
Simplified85.4%
Taylor expanded in y around 0 69.4%
Taylor expanded in t around 0 42.9%
*-commutative42.9%
exp-diff42.9%
mul-1-neg42.9%
log-rec42.9%
rem-exp-log43.8%
associate-/l/43.8%
associate-/r*43.8%
exp-neg43.8%
Simplified43.8%
Taylor expanded in b around 0 39.4%
if 9.59999999999999995e-232 < b Initial program 97.6%
*-commutative97.6%
associate-/l*92.0%
associate--l+92.0%
fma-define92.0%
sub-neg92.0%
metadata-eval92.0%
Simplified92.0%
Taylor expanded in y around 0 81.3%
Taylor expanded in t around 0 59.8%
*-commutative59.8%
exp-diff59.9%
mul-1-neg59.9%
log-rec59.9%
rem-exp-log60.5%
associate-/l/60.5%
associate-/r*60.5%
exp-neg60.5%
Simplified60.5%
Taylor expanded in b around 0 38.0%
*-commutative38.0%
Simplified38.0%
*-un-lft-identity38.0%
*-commutative38.0%
times-frac42.2%
Applied egg-rr42.2%
Final simplification43.2%
(FPCore (x y z t a b) :precision binary64 (if (<= b 1.55e-230) (/ (/ (- x (* x b)) a) y) (* (/ x y) (/ 1.0 a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= 1.55e-230) {
tmp = ((x - (x * b)) / a) / y;
} else {
tmp = (x / y) * (1.0 / 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.55d-230) then
tmp = ((x - (x * b)) / a) / y
else
tmp = (x / y) * (1.0d0 / 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.55e-230) {
tmp = ((x - (x * b)) / a) / y;
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= 1.55e-230: tmp = ((x - (x * b)) / a) / y else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= 1.55e-230) tmp = Float64(Float64(Float64(x - Float64(x * b)) / a) / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= 1.55e-230) tmp = ((x - (x * b)) / a) / y; else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, 1.55e-230], N[(N[(N[(x - N[(x * b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.55 \cdot 10^{-230}:\\
\;\;\;\;\frac{\frac{x - x \cdot b}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if b < 1.55e-230Initial program 97.9%
*-commutative97.9%
associate-/l*87.5%
associate--l+87.5%
fma-define87.5%
sub-neg87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in y around 0 76.1%
Taylor expanded in t around 0 56.5%
*-commutative56.5%
exp-diff56.5%
mul-1-neg56.5%
log-rec56.5%
rem-exp-log57.2%
associate-/l/57.2%
associate-/r*57.2%
exp-neg57.2%
Simplified57.2%
Taylor expanded in b around 0 42.7%
+-commutative42.7%
mul-1-neg42.7%
unsub-neg42.7%
*-commutative42.7%
associate-/l*42.7%
Simplified42.7%
Taylor expanded in a around 0 42.7%
if 1.55e-230 < b Initial program 97.6%
*-commutative97.6%
associate-/l*92.0%
associate--l+92.0%
fma-define92.0%
sub-neg92.0%
metadata-eval92.0%
Simplified92.0%
Taylor expanded in y around 0 81.3%
Taylor expanded in t around 0 59.8%
*-commutative59.8%
exp-diff59.9%
mul-1-neg59.9%
log-rec59.9%
rem-exp-log60.5%
associate-/l/60.5%
associate-/r*60.5%
exp-neg60.5%
Simplified60.5%
Taylor expanded in b around 0 38.0%
*-commutative38.0%
Simplified38.0%
*-un-lft-identity38.0%
*-commutative38.0%
times-frac42.2%
Applied egg-rr42.2%
Final simplification42.5%
(FPCore (x y z t a b) :precision binary64 (if (<= a 1.5e-93) (/ (/ x a) y) (* x (/ 1.0 (* y a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1.5e-93) {
tmp = (x / a) / y;
} else {
tmp = x * (1.0 / (y * a));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= 1.5d-93) then
tmp = (x / a) / y
else
tmp = x * (1.0d0 / (y * a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1.5e-93) {
tmp = (x / a) / y;
} else {
tmp = x * (1.0 / (y * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 1.5e-93: tmp = (x / a) / y else: tmp = x * (1.0 / (y * a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 1.5e-93) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x * Float64(1.0 / Float64(y * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 1.5e-93) tmp = (x / a) / y; else tmp = x * (1.0 / (y * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 1.5e-93], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x * N[(1.0 / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.5 \cdot 10^{-93}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{y \cdot a}\\
\end{array}
\end{array}
if a < 1.5000000000000001e-93Initial program 99.2%
*-commutative99.2%
associate-/l*90.5%
associate--l+90.5%
fma-define90.5%
sub-neg90.5%
metadata-eval90.5%
Simplified90.5%
Taylor expanded in y around 0 82.4%
Taylor expanded in t around 0 59.0%
*-commutative59.0%
exp-diff59.0%
mul-1-neg59.0%
log-rec59.0%
rem-exp-log59.7%
associate-/l/59.7%
associate-/r*59.7%
exp-neg59.7%
Simplified59.7%
Taylor expanded in b around 0 39.4%
if 1.5000000000000001e-93 < a Initial program 96.8%
*-commutative96.8%
associate-/l*88.8%
associate--l+88.8%
fma-define88.8%
sub-neg88.8%
metadata-eval88.8%
Simplified88.8%
Taylor expanded in y around 0 75.7%
Taylor expanded in t around 0 57.3%
*-commutative57.3%
exp-diff57.3%
mul-1-neg57.3%
log-rec57.3%
rem-exp-log57.9%
associate-/l/57.9%
associate-/r*57.9%
exp-neg57.9%
Simplified57.9%
Taylor expanded in b around 0 39.4%
*-commutative39.4%
Simplified39.4%
div-inv40.0%
*-commutative40.0%
Applied egg-rr40.0%
Final simplification39.8%
(FPCore (x y z t a b) :precision binary64 (if (<= a 7.8e-56) (* (/ x y) (/ 1.0 a)) (* x (/ 1.0 (* y a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 7.8e-56) {
tmp = (x / y) * (1.0 / a);
} else {
tmp = x * (1.0 / (y * a));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= 7.8d-56) then
tmp = (x / y) * (1.0d0 / a)
else
tmp = x * (1.0d0 / (y * a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 7.8e-56) {
tmp = (x / y) * (1.0 / a);
} else {
tmp = x * (1.0 / (y * a));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 7.8e-56: tmp = (x / y) * (1.0 / a) else: tmp = x * (1.0 / (y * a)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 7.8e-56) tmp = Float64(Float64(x / y) * Float64(1.0 / a)); else tmp = Float64(x * Float64(1.0 / Float64(y * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 7.8e-56) tmp = (x / y) * (1.0 / a); else tmp = x * (1.0 / (y * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 7.8e-56], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision], N[(x * N[(1.0 / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 7.8 \cdot 10^{-56}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{y \cdot a}\\
\end{array}
\end{array}
if a < 7.8e-56Initial program 99.2%
*-commutative99.2%
associate-/l*90.3%
associate--l+90.3%
fma-define90.3%
sub-neg90.3%
metadata-eval90.3%
Simplified90.3%
Taylor expanded in y around 0 78.8%
Taylor expanded in t around 0 58.4%
*-commutative58.4%
exp-diff58.4%
mul-1-neg58.4%
log-rec58.4%
rem-exp-log59.2%
associate-/l/59.2%
associate-/r*59.2%
exp-neg59.2%
Simplified59.2%
Taylor expanded in b around 0 32.3%
*-commutative32.3%
Simplified32.3%
*-un-lft-identity32.3%
*-commutative32.3%
times-frac41.4%
Applied egg-rr41.4%
if 7.8e-56 < a Initial program 96.5%
*-commutative96.5%
associate-/l*88.7%
associate--l+88.7%
fma-define88.7%
sub-neg88.7%
metadata-eval88.7%
Simplified88.7%
Taylor expanded in y around 0 78.0%
Taylor expanded in t around 0 57.6%
*-commutative57.6%
exp-diff57.6%
mul-1-neg57.6%
log-rec57.6%
rem-exp-log58.1%
associate-/l/58.1%
associate-/r*58.1%
exp-neg58.1%
Simplified58.1%
Taylor expanded in b around 0 39.1%
*-commutative39.1%
Simplified39.1%
div-inv39.7%
*-commutative39.7%
Applied egg-rr39.7%
Final simplification40.5%
(FPCore (x y z t a b) :precision binary64 (if (<= a 1e-93) (/ (/ x a) y) (/ x (* y a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1e-93) {
tmp = (x / a) / y;
} else {
tmp = x / (y * a);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (a <= 1d-93) then
tmp = (x / a) / y
else
tmp = x / (y * a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1e-93) {
tmp = (x / a) / y;
} else {
tmp = x / (y * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 1e-93: tmp = (x / a) / y else: tmp = x / (y * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 1e-93) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(y * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 1e-93) tmp = (x / a) / y; else tmp = x / (y * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 1e-93], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 10^{-93}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\end{array}
\end{array}
if a < 9.999999999999999e-94Initial program 99.2%
*-commutative99.2%
associate-/l*90.5%
associate--l+90.5%
fma-define90.5%
sub-neg90.5%
metadata-eval90.5%
Simplified90.5%
Taylor expanded in y around 0 82.4%
Taylor expanded in t around 0 59.0%
*-commutative59.0%
exp-diff59.0%
mul-1-neg59.0%
log-rec59.0%
rem-exp-log59.7%
associate-/l/59.7%
associate-/r*59.7%
exp-neg59.7%
Simplified59.7%
Taylor expanded in b around 0 39.4%
if 9.999999999999999e-94 < a Initial program 96.8%
*-commutative96.8%
associate-/l*88.8%
associate--l+88.8%
fma-define88.8%
sub-neg88.8%
metadata-eval88.8%
Simplified88.8%
Taylor expanded in y around 0 75.7%
Taylor expanded in t around 0 57.3%
*-commutative57.3%
exp-diff57.3%
mul-1-neg57.3%
log-rec57.3%
rem-exp-log57.9%
associate-/l/57.9%
associate-/r*57.9%
exp-neg57.9%
Simplified57.9%
Taylor expanded in b around 0 39.4%
*-commutative39.4%
Simplified39.4%
Final simplification39.4%
(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 97.8%
*-commutative97.8%
associate-/l*89.5%
associate--l+89.5%
fma-define89.5%
sub-neg89.5%
metadata-eval89.5%
Simplified89.5%
Taylor expanded in y around 0 78.4%
Taylor expanded in t around 0 58.0%
*-commutative58.0%
exp-diff58.0%
mul-1-neg58.0%
log-rec58.0%
rem-exp-log58.7%
associate-/l/58.7%
associate-/r*58.7%
exp-neg58.7%
Simplified58.7%
Taylor expanded in b around 0 35.8%
*-commutative35.8%
Simplified35.8%
Final simplification35.8%
(FPCore (x y z t a b) :precision binary64 (/ x y))
double code(double x, double y, double z, double t, double a, double b) {
return x / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / y;
}
def code(x, y, z, t, a, b): return x / y
function code(x, y, z, t, a, b) return Float64(x / y) end
function tmp = code(x, y, z, t, a, b) tmp = x / y; end
code[x_, y_, z_, t_, a_, b_] := N[(x / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y}
\end{array}
Initial program 97.8%
*-commutative97.8%
associate-/l*89.5%
associate--l+89.5%
fma-define89.5%
sub-neg89.5%
metadata-eval89.5%
Simplified89.5%
Taylor expanded in b around inf 42.0%
neg-mul-142.0%
Simplified42.0%
Taylor expanded in b around 0 18.2%
Final simplification18.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (pow a (- t 1.0)))
(t_2 (/ (* x (/ t_1 y)) (- (+ b 1.0) (* y (log z))))))
(if (< t -0.8845848504127471)
t_2
(if (< t 852031.2288374073)
(/ (* (/ x y) t_1) (exp (- b (* (log z) y))))
t_2))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = pow(a, (t - 1.0));
double t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * log(z)));
double tmp;
if (t < -0.8845848504127471) {
tmp = t_2;
} else if (t < 852031.2288374073) {
tmp = ((x / y) * t_1) / exp((b - (log(z) * y)));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a ** (t - 1.0d0)
t_2 = (x * (t_1 / y)) / ((b + 1.0d0) - (y * log(z)))
if (t < (-0.8845848504127471d0)) then
tmp = t_2
else if (t < 852031.2288374073d0) then
tmp = ((x / y) * t_1) / exp((b - (log(z) * y)))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = Math.pow(a, (t - 1.0));
double t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * Math.log(z)));
double tmp;
if (t < -0.8845848504127471) {
tmp = t_2;
} else if (t < 852031.2288374073) {
tmp = ((x / y) * t_1) / Math.exp((b - (Math.log(z) * y)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = math.pow(a, (t - 1.0)) t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * math.log(z))) tmp = 0 if t < -0.8845848504127471: tmp = t_2 elif t < 852031.2288374073: tmp = ((x / y) * t_1) / math.exp((b - (math.log(z) * y))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = a ^ Float64(t - 1.0) t_2 = Float64(Float64(x * Float64(t_1 / y)) / Float64(Float64(b + 1.0) - Float64(y * log(z)))) tmp = 0.0 if (t < -0.8845848504127471) tmp = t_2; elseif (t < 852031.2288374073) tmp = Float64(Float64(Float64(x / y) * t_1) / exp(Float64(b - Float64(log(z) * y)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a ^ (t - 1.0); t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * log(z))); tmp = 0.0; if (t < -0.8845848504127471) tmp = t_2; elseif (t < 852031.2288374073) tmp = ((x / y) * t_1) / exp((b - (log(z) * y))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[Power[a, N[(t - 1.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision] / N[(N[(b + 1.0), $MachinePrecision] - N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -0.8845848504127471], t$95$2, If[Less[t, 852031.2288374073], N[(N[(N[(x / y), $MachinePrecision] * t$95$1), $MachinePrecision] / N[Exp[N[(b - N[(N[Log[z], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {a}^{\left(t - 1\right)}\\
t_2 := \frac{x \cdot \frac{t\_1}{y}}{\left(b + 1\right) - y \cdot \log z}\\
\mathbf{if}\;t < -0.8845848504127471:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 852031.2288374073:\\
\;\;\;\;\frac{\frac{x}{y} \cdot t\_1}{e^{b - \log z \cdot y}}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024059
(FPCore (x y z t a b)
:name "Numeric.SpecFunctions:incompleteBetaWorker from math-functions-0.1.5.2, A"
:precision binary64
:alt
(if (< t -0.8845848504127471) (/ (* x (/ (pow a (- t 1.0)) y)) (- (+ b 1.0) (* y (log z)))) (if (< t 852031.2288374073) (/ (* (/ x y) (pow a (- t 1.0))) (exp (- b (* (log z) y)))) (/ (* x (/ (pow a (- t 1.0)) y)) (- (+ b 1.0) (* y (log z))))))
(/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))