
(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 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}
\end{array}
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (+ t -1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t + (-1.0d0)) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t + -1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t + -1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t + -1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t + -1\right) \cdot \log a\right) - b}}{y}
\end{array}
Initial program 98.8%
Final simplification98.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (/ x (exp b)) y))
(t_2 (* x (* (pow a (+ t -1.0)) (/ (pow z y) y)))))
(if (<= b -1.65e+110)
(/
(* x (+ 1.0 (* b (+ (* b (+ 0.5 (* b -0.16666666666666666))) -1.0))))
y)
(if (<= b -3.9e+58)
t_2
(if (<= b -2.8e+29)
t_1
(if (<= b -5.8e-145)
t_2
(if (<= b -1.76e-152)
(* (/ x a) (/ (pow a t) y))
(if (<= b -1.7e-205)
(* (/ (pow z y) a) (/ x y))
(if (<= b 1.35e+44) t_2 t_1)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / exp(b)) / y;
double t_2 = x * (pow(a, (t + -1.0)) * (pow(z, y) / y));
double tmp;
if (b <= -1.65e+110) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -3.9e+58) {
tmp = t_2;
} else if (b <= -2.8e+29) {
tmp = t_1;
} else if (b <= -5.8e-145) {
tmp = t_2;
} else if (b <= -1.76e-152) {
tmp = (x / a) * (pow(a, t) / y);
} else if (b <= -1.7e-205) {
tmp = (pow(z, y) / a) * (x / y);
} else if (b <= 1.35e+44) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x / exp(b)) / y
t_2 = x * ((a ** (t + (-1.0d0))) * ((z ** y) / y))
if (b <= (-1.65d+110)) then
tmp = (x * (1.0d0 + (b * ((b * (0.5d0 + (b * (-0.16666666666666666d0)))) + (-1.0d0))))) / y
else if (b <= (-3.9d+58)) then
tmp = t_2
else if (b <= (-2.8d+29)) then
tmp = t_1
else if (b <= (-5.8d-145)) then
tmp = t_2
else if (b <= (-1.76d-152)) then
tmp = (x / a) * ((a ** t) / y)
else if (b <= (-1.7d-205)) then
tmp = ((z ** y) / a) * (x / y)
else if (b <= 1.35d+44) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / Math.exp(b)) / y;
double t_2 = x * (Math.pow(a, (t + -1.0)) * (Math.pow(z, y) / y));
double tmp;
if (b <= -1.65e+110) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -3.9e+58) {
tmp = t_2;
} else if (b <= -2.8e+29) {
tmp = t_1;
} else if (b <= -5.8e-145) {
tmp = t_2;
} else if (b <= -1.76e-152) {
tmp = (x / a) * (Math.pow(a, t) / y);
} else if (b <= -1.7e-205) {
tmp = (Math.pow(z, y) / a) * (x / y);
} else if (b <= 1.35e+44) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x / math.exp(b)) / y t_2 = x * (math.pow(a, (t + -1.0)) * (math.pow(z, y) / y)) tmp = 0 if b <= -1.65e+110: tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y elif b <= -3.9e+58: tmp = t_2 elif b <= -2.8e+29: tmp = t_1 elif b <= -5.8e-145: tmp = t_2 elif b <= -1.76e-152: tmp = (x / a) * (math.pow(a, t) / y) elif b <= -1.7e-205: tmp = (math.pow(z, y) / a) * (x / y) elif b <= 1.35e+44: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x / exp(b)) / y) t_2 = Float64(x * Float64((a ^ Float64(t + -1.0)) * Float64((z ^ y) / y))) tmp = 0.0 if (b <= -1.65e+110) tmp = Float64(Float64(x * Float64(1.0 + Float64(b * Float64(Float64(b * Float64(0.5 + Float64(b * -0.16666666666666666))) + -1.0)))) / y); elseif (b <= -3.9e+58) tmp = t_2; elseif (b <= -2.8e+29) tmp = t_1; elseif (b <= -5.8e-145) tmp = t_2; elseif (b <= -1.76e-152) tmp = Float64(Float64(x / a) * Float64((a ^ t) / y)); elseif (b <= -1.7e-205) tmp = Float64(Float64((z ^ y) / a) * Float64(x / y)); elseif (b <= 1.35e+44) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x / exp(b)) / y; t_2 = x * ((a ^ (t + -1.0)) * ((z ^ y) / y)); tmp = 0.0; if (b <= -1.65e+110) tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y; elseif (b <= -3.9e+58) tmp = t_2; elseif (b <= -2.8e+29) tmp = t_1; elseif (b <= -5.8e-145) tmp = t_2; elseif (b <= -1.76e-152) tmp = (x / a) * ((a ^ t) / y); elseif (b <= -1.7e-205) tmp = ((z ^ y) / a) * (x / y); elseif (b <= 1.35e+44) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x / N[Exp[b], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] * N[(N[Power[z, y], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.65e+110], N[(N[(x * N[(1.0 + N[(b * N[(N[(b * N[(0.5 + N[(b * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -3.9e+58], t$95$2, If[LessEqual[b, -2.8e+29], t$95$1, If[LessEqual[b, -5.8e-145], t$95$2, If[LessEqual[b, -1.76e-152], N[(N[(x / a), $MachinePrecision] * N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.7e-205], N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.35e+44], t$95$2, t$95$1]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{x}{e^{b}}}{y}\\
t_2 := x \cdot \left({a}^{\left(t + -1\right)} \cdot \frac{{z}^{y}}{y}\right)\\
\mathbf{if}\;b \leq -1.65 \cdot 10^{+110}:\\
\;\;\;\;\frac{x \cdot \left(1 + b \cdot \left(b \cdot \left(0.5 + b \cdot -0.16666666666666666\right) + -1\right)\right)}{y}\\
\mathbf{elif}\;b \leq -3.9 \cdot 10^{+58}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -2.8 \cdot 10^{+29}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -5.8 \cdot 10^{-145}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -1.76 \cdot 10^{-152}:\\
\;\;\;\;\frac{x}{a} \cdot \frac{{a}^{t}}{y}\\
\mathbf{elif}\;b \leq -1.7 \cdot 10^{-205}:\\
\;\;\;\;\frac{{z}^{y}}{a} \cdot \frac{x}{y}\\
\mathbf{elif}\;b \leq 1.35 \cdot 10^{+44}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.64999999999999986e110Initial program 100.0%
*-commutative100.0%
associate-/l*87.5%
associate--l+87.5%
fma-define87.5%
sub-neg87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in b around inf 81.3%
neg-mul-181.3%
Simplified81.3%
Taylor expanded in b around 0 74.4%
Taylor expanded in y around 0 83.9%
Taylor expanded in x around 0 87.9%
Taylor expanded in x around 0 93.8%
if -1.64999999999999986e110 < b < -3.9000000000000001e58 or -2.8e29 < b < -5.79999999999999968e-145 or -1.7000000000000001e-205 < b < 1.35e44Initial program 98.7%
associate-/l*96.3%
associate--l+96.3%
exp-sum81.9%
associate-/l*80.4%
*-commutative80.4%
exp-to-pow80.4%
exp-diff74.7%
*-commutative74.7%
exp-to-pow75.6%
sub-neg75.6%
metadata-eval75.6%
Simplified75.6%
Taylor expanded in b around 0 85.6%
associate-/l*85.6%
exp-to-pow86.4%
sub-neg86.4%
metadata-eval86.4%
Simplified86.4%
if -3.9000000000000001e58 < b < -2.8e29 or 1.35e44 < 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 b around inf 76.9%
neg-mul-176.9%
Simplified76.9%
associate-*r/89.5%
Applied egg-rr89.5%
Taylor expanded in b around inf 89.5%
exp-neg89.5%
associate-*r/89.5%
*-rgt-identity89.5%
Simplified89.5%
if -5.79999999999999968e-145 < b < -1.76000000000000001e-152Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum66.7%
associate-/l*66.7%
*-commutative66.7%
exp-to-pow66.7%
exp-diff66.7%
*-commutative66.7%
exp-to-pow66.7%
sub-neg66.7%
metadata-eval66.7%
Simplified66.7%
Taylor expanded in y around 0 100.0%
associate-/r*100.0%
exp-to-pow100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
unpow-prod-up100.0%
unpow-1100.0%
Applied egg-rr100.0%
associate-*r/100.0%
*-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 100.0%
times-frac100.0%
Simplified100.0%
Taylor expanded in b around 0 100.0%
if -1.76000000000000001e-152 < b < -1.7000000000000001e-205Initial program 87.3%
associate-/l*88.0%
associate--l+88.0%
exp-sum78.0%
associate-/l*78.0%
*-commutative78.0%
exp-to-pow78.0%
exp-diff78.0%
*-commutative78.0%
exp-to-pow80.3%
sub-neg80.3%
metadata-eval80.3%
Simplified80.3%
Taylor expanded in t around 0 80.5%
Taylor expanded in b around 0 80.5%
*-commutative80.5%
times-frac100.0%
Simplified100.0%
Final simplification89.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (exp b))) (t_2 (/ (* x (/ (pow z y) a)) y)))
(if (<= y -950000000000.0)
t_2
(if (<= y -1.45e-21)
(/ x (* a t_1))
(if (<= y 4e-30) (/ (* x (/ (pow a t) t_1)) a) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * exp(b);
double t_2 = (x * (pow(z, y) / a)) / y;
double tmp;
if (y <= -950000000000.0) {
tmp = t_2;
} else if (y <= -1.45e-21) {
tmp = x / (a * t_1);
} else if (y <= 4e-30) {
tmp = (x * (pow(a, t) / t_1)) / a;
} 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 = y * exp(b)
t_2 = (x * ((z ** y) / a)) / y
if (y <= (-950000000000.0d0)) then
tmp = t_2
else if (y <= (-1.45d-21)) then
tmp = x / (a * t_1)
else if (y <= 4d-30) then
tmp = (x * ((a ** t) / t_1)) / a
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 = y * Math.exp(b);
double t_2 = (x * (Math.pow(z, y) / a)) / y;
double tmp;
if (y <= -950000000000.0) {
tmp = t_2;
} else if (y <= -1.45e-21) {
tmp = x / (a * t_1);
} else if (y <= 4e-30) {
tmp = (x * (Math.pow(a, t) / t_1)) / a;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * math.exp(b) t_2 = (x * (math.pow(z, y) / a)) / y tmp = 0 if y <= -950000000000.0: tmp = t_2 elif y <= -1.45e-21: tmp = x / (a * t_1) elif y <= 4e-30: tmp = (x * (math.pow(a, t) / t_1)) / a else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * exp(b)) t_2 = Float64(Float64(x * Float64((z ^ y) / a)) / y) tmp = 0.0 if (y <= -950000000000.0) tmp = t_2; elseif (y <= -1.45e-21) tmp = Float64(x / Float64(a * t_1)); elseif (y <= 4e-30) tmp = Float64(Float64(x * Float64((a ^ t) / t_1)) / a); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * exp(b); t_2 = (x * ((z ^ y) / a)) / y; tmp = 0.0; if (y <= -950000000000.0) tmp = t_2; elseif (y <= -1.45e-21) tmp = x / (a * t_1); elseif (y <= 4e-30) tmp = (x * ((a ^ t) / t_1)) / a; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -950000000000.0], t$95$2, If[LessEqual[y, -1.45e-21], N[(x / N[(a * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4e-30], N[(N[(x * N[(N[Power[a, t], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot e^{b}\\
t_2 := \frac{x \cdot \frac{{z}^{y}}{a}}{y}\\
\mathbf{if}\;y \leq -950000000000:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -1.45 \cdot 10^{-21}:\\
\;\;\;\;\frac{x}{a \cdot t\_1}\\
\mathbf{elif}\;y \leq 4 \cdot 10^{-30}:\\
\;\;\;\;\frac{x \cdot \frac{{a}^{t}}{t\_1}}{a}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -9.5e11 or 4e-30 < y Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum66.9%
associate-/l*65.4%
*-commutative65.4%
exp-to-pow65.4%
exp-diff57.5%
*-commutative57.5%
exp-to-pow57.5%
sub-neg57.5%
metadata-eval57.5%
Simplified57.5%
Taylor expanded in t around 0 63.1%
Taylor expanded in b around 0 69.6%
*-commutative69.6%
times-frac70.4%
Simplified70.4%
associate-*l/80.7%
Applied egg-rr80.7%
if -9.5e11 < y < -1.45e-21Initial 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-diff70.0%
*-commutative70.0%
exp-to-pow70.0%
sub-neg70.0%
metadata-eval70.0%
Simplified70.0%
Taylor expanded in y around 0 80.5%
associate-/r*70.5%
exp-to-pow70.5%
sub-neg70.5%
metadata-eval70.5%
Simplified70.5%
Taylor expanded in t around 0 90.5%
if -1.45e-21 < y < 4e-30Initial program 97.4%
associate-/l*94.6%
associate--l+94.6%
exp-sum94.6%
associate-/l*94.6%
*-commutative94.6%
exp-to-pow94.6%
exp-diff87.1%
*-commutative87.1%
exp-to-pow88.3%
sub-neg88.3%
metadata-eval88.3%
Simplified88.3%
Taylor expanded in y around 0 87.1%
associate-/r*83.7%
exp-to-pow85.0%
sub-neg85.0%
metadata-eval85.0%
Simplified85.0%
unpow-prod-up85.0%
unpow-185.0%
Applied egg-rr85.0%
associate-*r/85.0%
*-rgt-identity85.0%
Simplified85.0%
Taylor expanded in x around 0 87.3%
times-frac87.3%
Simplified87.3%
associate-*l/90.0%
Applied egg-rr90.0%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -2100000000000.0) (not (<= y 4.5e+79))) (/ (* x (/ (pow z y) a)) y) (/ (* x (exp (- (* (+ t -1.0) (log a)) b))) y)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -2100000000000.0) || !(y <= 4.5e+79)) {
tmp = (x * (pow(z, y) / a)) / y;
} else {
tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((y <= (-2100000000000.0d0)) .or. (.not. (y <= 4.5d+79))) then
tmp = (x * ((z ** y) / a)) / y
else
tmp = (x * exp((((t + (-1.0d0)) * log(a)) - b))) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -2100000000000.0) || !(y <= 4.5e+79)) {
tmp = (x * (Math.pow(z, y) / a)) / y;
} else {
tmp = (x * Math.exp((((t + -1.0) * Math.log(a)) - b))) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -2100000000000.0) or not (y <= 4.5e+79): tmp = (x * (math.pow(z, y) / a)) / y else: tmp = (x * math.exp((((t + -1.0) * math.log(a)) - b))) / y return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -2100000000000.0) || !(y <= 4.5e+79)) tmp = Float64(Float64(x * Float64((z ^ y) / a)) / y); else tmp = Float64(Float64(x * exp(Float64(Float64(Float64(t + -1.0) * log(a)) - b))) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((y <= -2100000000000.0) || ~((y <= 4.5e+79))) tmp = (x * ((z ^ y) / a)) / y; else tmp = (x * exp((((t + -1.0) * log(a)) - b))) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -2100000000000.0], N[Not[LessEqual[y, 4.5e+79]], $MachinePrecision]], N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * N[Exp[N[(N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2100000000000 \lor \neg \left(y \leq 4.5 \cdot 10^{+79}\right):\\
\;\;\;\;\frac{x \cdot \frac{{z}^{y}}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot e^{\left(t + -1\right) \cdot \log a - b}}{y}\\
\end{array}
\end{array}
if y < -2.1e12 or 4.49999999999999994e79 < y Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum66.4%
associate-/l*64.5%
*-commutative64.5%
exp-to-pow64.5%
exp-diff57.0%
*-commutative57.0%
exp-to-pow57.0%
sub-neg57.0%
metadata-eval57.0%
Simplified57.0%
Taylor expanded in t around 0 63.6%
Taylor expanded in b around 0 72.2%
*-commutative72.2%
times-frac72.2%
Simplified72.2%
associate-*l/84.4%
Applied egg-rr84.4%
if -2.1e12 < y < 4.49999999999999994e79Initial program 97.9%
*-commutative97.9%
associate-/l*92.2%
associate--l+92.2%
fma-define92.2%
sub-neg92.2%
metadata-eval92.2%
Simplified92.2%
Taylor expanded in y around 0 96.0%
Final simplification91.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (/ x (exp b)) y))
(t_2 (* (/ (pow z y) a) (/ x y)))
(t_3 (* (/ x a) (/ (pow a t) y))))
(if (<= b -7e+109)
(/
(* x (+ 1.0 (* b (+ (* b (+ 0.5 (* b -0.16666666666666666))) -1.0))))
y)
(if (<= b -1.6e+80)
t_2
(if (<= b -3.2e+20)
t_1
(if (<= b 4.7e-299)
t_2
(if (<= b 4.4e-194)
t_3
(if (<= b 1.5e-151)
t_2
(if (<= b 0.12)
t_3
(if (<= b 1.12e+104)
(/ x (* a (* y (exp b))))
(if (<= b 1.05e+106)
t_3
(if (<= b 9.2e+126) t_2 t_1))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / exp(b)) / y;
double t_2 = (pow(z, y) / a) * (x / y);
double t_3 = (x / a) * (pow(a, t) / y);
double tmp;
if (b <= -7e+109) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -1.6e+80) {
tmp = t_2;
} else if (b <= -3.2e+20) {
tmp = t_1;
} else if (b <= 4.7e-299) {
tmp = t_2;
} else if (b <= 4.4e-194) {
tmp = t_3;
} else if (b <= 1.5e-151) {
tmp = t_2;
} else if (b <= 0.12) {
tmp = t_3;
} else if (b <= 1.12e+104) {
tmp = x / (a * (y * exp(b)));
} else if (b <= 1.05e+106) {
tmp = t_3;
} else if (b <= 9.2e+126) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = (x / exp(b)) / y
t_2 = ((z ** y) / a) * (x / y)
t_3 = (x / a) * ((a ** t) / y)
if (b <= (-7d+109)) then
tmp = (x * (1.0d0 + (b * ((b * (0.5d0 + (b * (-0.16666666666666666d0)))) + (-1.0d0))))) / y
else if (b <= (-1.6d+80)) then
tmp = t_2
else if (b <= (-3.2d+20)) then
tmp = t_1
else if (b <= 4.7d-299) then
tmp = t_2
else if (b <= 4.4d-194) then
tmp = t_3
else if (b <= 1.5d-151) then
tmp = t_2
else if (b <= 0.12d0) then
tmp = t_3
else if (b <= 1.12d+104) then
tmp = x / (a * (y * exp(b)))
else if (b <= 1.05d+106) then
tmp = t_3
else if (b <= 9.2d+126) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / Math.exp(b)) / y;
double t_2 = (Math.pow(z, y) / a) * (x / y);
double t_3 = (x / a) * (Math.pow(a, t) / y);
double tmp;
if (b <= -7e+109) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -1.6e+80) {
tmp = t_2;
} else if (b <= -3.2e+20) {
tmp = t_1;
} else if (b <= 4.7e-299) {
tmp = t_2;
} else if (b <= 4.4e-194) {
tmp = t_3;
} else if (b <= 1.5e-151) {
tmp = t_2;
} else if (b <= 0.12) {
tmp = t_3;
} else if (b <= 1.12e+104) {
tmp = x / (a * (y * Math.exp(b)));
} else if (b <= 1.05e+106) {
tmp = t_3;
} else if (b <= 9.2e+126) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x / math.exp(b)) / y t_2 = (math.pow(z, y) / a) * (x / y) t_3 = (x / a) * (math.pow(a, t) / y) tmp = 0 if b <= -7e+109: tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y elif b <= -1.6e+80: tmp = t_2 elif b <= -3.2e+20: tmp = t_1 elif b <= 4.7e-299: tmp = t_2 elif b <= 4.4e-194: tmp = t_3 elif b <= 1.5e-151: tmp = t_2 elif b <= 0.12: tmp = t_3 elif b <= 1.12e+104: tmp = x / (a * (y * math.exp(b))) elif b <= 1.05e+106: tmp = t_3 elif b <= 9.2e+126: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x / exp(b)) / y) t_2 = Float64(Float64((z ^ y) / a) * Float64(x / y)) t_3 = Float64(Float64(x / a) * Float64((a ^ t) / y)) tmp = 0.0 if (b <= -7e+109) tmp = Float64(Float64(x * Float64(1.0 + Float64(b * Float64(Float64(b * Float64(0.5 + Float64(b * -0.16666666666666666))) + -1.0)))) / y); elseif (b <= -1.6e+80) tmp = t_2; elseif (b <= -3.2e+20) tmp = t_1; elseif (b <= 4.7e-299) tmp = t_2; elseif (b <= 4.4e-194) tmp = t_3; elseif (b <= 1.5e-151) tmp = t_2; elseif (b <= 0.12) tmp = t_3; elseif (b <= 1.12e+104) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); elseif (b <= 1.05e+106) tmp = t_3; elseif (b <= 9.2e+126) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x / exp(b)) / y; t_2 = ((z ^ y) / a) * (x / y); t_3 = (x / a) * ((a ^ t) / y); tmp = 0.0; if (b <= -7e+109) tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y; elseif (b <= -1.6e+80) tmp = t_2; elseif (b <= -3.2e+20) tmp = t_1; elseif (b <= 4.7e-299) tmp = t_2; elseif (b <= 4.4e-194) tmp = t_3; elseif (b <= 1.5e-151) tmp = t_2; elseif (b <= 0.12) tmp = t_3; elseif (b <= 1.12e+104) tmp = x / (a * (y * exp(b))); elseif (b <= 1.05e+106) tmp = t_3; elseif (b <= 9.2e+126) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x / N[Exp[b], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x / a), $MachinePrecision] * N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7e+109], N[(N[(x * N[(1.0 + N[(b * N[(N[(b * N[(0.5 + N[(b * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.6e+80], t$95$2, If[LessEqual[b, -3.2e+20], t$95$1, If[LessEqual[b, 4.7e-299], t$95$2, If[LessEqual[b, 4.4e-194], t$95$3, If[LessEqual[b, 1.5e-151], t$95$2, If[LessEqual[b, 0.12], t$95$3, If[LessEqual[b, 1.12e+104], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.05e+106], t$95$3, If[LessEqual[b, 9.2e+126], t$95$2, t$95$1]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{x}{e^{b}}}{y}\\
t_2 := \frac{{z}^{y}}{a} \cdot \frac{x}{y}\\
t_3 := \frac{x}{a} \cdot \frac{{a}^{t}}{y}\\
\mathbf{if}\;b \leq -7 \cdot 10^{+109}:\\
\;\;\;\;\frac{x \cdot \left(1 + b \cdot \left(b \cdot \left(0.5 + b \cdot -0.16666666666666666\right) + -1\right)\right)}{y}\\
\mathbf{elif}\;b \leq -1.6 \cdot 10^{+80}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -3.2 \cdot 10^{+20}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 4.7 \cdot 10^{-299}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 4.4 \cdot 10^{-194}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;b \leq 1.5 \cdot 10^{-151}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 0.12:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;b \leq 1.12 \cdot 10^{+104}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{elif}\;b \leq 1.05 \cdot 10^{+106}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;b \leq 9.2 \cdot 10^{+126}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -6.99999999999999966e109Initial program 100.0%
*-commutative100.0%
associate-/l*87.5%
associate--l+87.5%
fma-define87.5%
sub-neg87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in b around inf 81.3%
neg-mul-181.3%
Simplified81.3%
Taylor expanded in b around 0 74.4%
Taylor expanded in y around 0 83.9%
Taylor expanded in x around 0 87.9%
Taylor expanded in x around 0 93.8%
if -6.99999999999999966e109 < b < -1.59999999999999995e80 or -3.2e20 < b < 4.6999999999999997e-299 or 4.4000000000000003e-194 < b < 1.5e-151 or 1.05000000000000002e106 < b < 9.2000000000000002e126Initial program 97.6%
associate-/l*95.9%
associate--l+95.9%
exp-sum81.5%
associate-/l*80.5%
*-commutative80.5%
exp-to-pow80.5%
exp-diff75.3%
*-commutative75.3%
exp-to-pow76.3%
sub-neg76.3%
metadata-eval76.3%
Simplified76.3%
Taylor expanded in t around 0 65.4%
Taylor expanded in b around 0 72.6%
*-commutative72.6%
times-frac76.6%
Simplified76.6%
if -1.59999999999999995e80 < b < -3.2e20 or 9.2000000000000002e126 < b Initial program 100.0%
*-commutative100.0%
associate-/l*87.8%
associate--l+87.8%
fma-define87.8%
sub-neg87.8%
metadata-eval87.8%
Simplified87.8%
Taylor expanded in b around inf 77.6%
neg-mul-177.6%
Simplified77.6%
associate-*r/90.0%
Applied egg-rr90.0%
Taylor expanded in b around inf 90.0%
exp-neg90.0%
associate-*r/90.0%
*-rgt-identity90.0%
Simplified90.0%
if 4.6999999999999997e-299 < b < 4.4000000000000003e-194 or 1.5e-151 < b < 0.12 or 1.12000000000000003e104 < b < 1.05000000000000002e106Initial program 98.3%
associate-/l*94.6%
associate--l+94.6%
exp-sum85.7%
associate-/l*83.5%
*-commutative83.5%
exp-to-pow83.5%
exp-diff83.5%
*-commutative83.5%
exp-to-pow84.6%
sub-neg84.6%
metadata-eval84.6%
Simplified84.6%
Taylor expanded in y around 0 79.5%
associate-/r*79.5%
exp-to-pow80.6%
sub-neg80.6%
metadata-eval80.6%
Simplified80.6%
unpow-prod-up80.6%
unpow-180.6%
Applied egg-rr80.6%
associate-*r/80.6%
*-rgt-identity80.6%
Simplified80.6%
Taylor expanded in x around 0 80.7%
times-frac80.3%
Simplified80.3%
Taylor expanded in b around 0 82.5%
if 0.12 < b < 1.12000000000000003e104Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum58.8%
associate-/l*58.8%
*-commutative58.8%
exp-to-pow58.8%
exp-diff41.2%
*-commutative41.2%
exp-to-pow41.2%
sub-neg41.2%
metadata-eval41.2%
Simplified41.2%
Taylor expanded in y around 0 47.5%
associate-/r*35.8%
exp-to-pow35.8%
sub-neg35.8%
metadata-eval35.8%
Simplified35.8%
Taylor expanded in t around 0 59.5%
Final simplification82.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* a (* y (exp b)))))
(t_2 (* (/ (pow z y) a) (/ x y)))
(t_3 (/ (pow a t) y)))
(if (<= y -2900000000000.0)
t_2
(if (<= y -1.16e-57)
t_1
(if (<= y -1.35e-185)
(/ (* x t_3) a)
(if (<= y -8.4e-237)
t_1
(if (<= y -5.5e-290)
(* (/ x a) t_3)
(if (<= y 4.2e+124)
t_1
(if (<= y 2.65e+295) t_2 (/ (/ x (exp b)) y))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a * (y * exp(b)));
double t_2 = (pow(z, y) / a) * (x / y);
double t_3 = pow(a, t) / y;
double tmp;
if (y <= -2900000000000.0) {
tmp = t_2;
} else if (y <= -1.16e-57) {
tmp = t_1;
} else if (y <= -1.35e-185) {
tmp = (x * t_3) / a;
} else if (y <= -8.4e-237) {
tmp = t_1;
} else if (y <= -5.5e-290) {
tmp = (x / a) * t_3;
} else if (y <= 4.2e+124) {
tmp = t_1;
} else if (y <= 2.65e+295) {
tmp = t_2;
} else {
tmp = (x / exp(b)) / y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x / (a * (y * exp(b)))
t_2 = ((z ** y) / a) * (x / y)
t_3 = (a ** t) / y
if (y <= (-2900000000000.0d0)) then
tmp = t_2
else if (y <= (-1.16d-57)) then
tmp = t_1
else if (y <= (-1.35d-185)) then
tmp = (x * t_3) / a
else if (y <= (-8.4d-237)) then
tmp = t_1
else if (y <= (-5.5d-290)) then
tmp = (x / a) * t_3
else if (y <= 4.2d+124) then
tmp = t_1
else if (y <= 2.65d+295) then
tmp = t_2
else
tmp = (x / exp(b)) / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a * (y * Math.exp(b)));
double t_2 = (Math.pow(z, y) / a) * (x / y);
double t_3 = Math.pow(a, t) / y;
double tmp;
if (y <= -2900000000000.0) {
tmp = t_2;
} else if (y <= -1.16e-57) {
tmp = t_1;
} else if (y <= -1.35e-185) {
tmp = (x * t_3) / a;
} else if (y <= -8.4e-237) {
tmp = t_1;
} else if (y <= -5.5e-290) {
tmp = (x / a) * t_3;
} else if (y <= 4.2e+124) {
tmp = t_1;
} else if (y <= 2.65e+295) {
tmp = t_2;
} else {
tmp = (x / Math.exp(b)) / y;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a * (y * math.exp(b))) t_2 = (math.pow(z, y) / a) * (x / y) t_3 = math.pow(a, t) / y tmp = 0 if y <= -2900000000000.0: tmp = t_2 elif y <= -1.16e-57: tmp = t_1 elif y <= -1.35e-185: tmp = (x * t_3) / a elif y <= -8.4e-237: tmp = t_1 elif y <= -5.5e-290: tmp = (x / a) * t_3 elif y <= 4.2e+124: tmp = t_1 elif y <= 2.65e+295: tmp = t_2 else: tmp = (x / math.exp(b)) / y return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a * Float64(y * exp(b)))) t_2 = Float64(Float64((z ^ y) / a) * Float64(x / y)) t_3 = Float64((a ^ t) / y) tmp = 0.0 if (y <= -2900000000000.0) tmp = t_2; elseif (y <= -1.16e-57) tmp = t_1; elseif (y <= -1.35e-185) tmp = Float64(Float64(x * t_3) / a); elseif (y <= -8.4e-237) tmp = t_1; elseif (y <= -5.5e-290) tmp = Float64(Float64(x / a) * t_3); elseif (y <= 4.2e+124) tmp = t_1; elseif (y <= 2.65e+295) tmp = t_2; else tmp = Float64(Float64(x / exp(b)) / y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a * (y * exp(b))); t_2 = ((z ^ y) / a) * (x / y); t_3 = (a ^ t) / y; tmp = 0.0; if (y <= -2900000000000.0) tmp = t_2; elseif (y <= -1.16e-57) tmp = t_1; elseif (y <= -1.35e-185) tmp = (x * t_3) / a; elseif (y <= -8.4e-237) tmp = t_1; elseif (y <= -5.5e-290) tmp = (x / a) * t_3; elseif (y <= 4.2e+124) tmp = t_1; elseif (y <= 2.65e+295) tmp = t_2; else tmp = (x / exp(b)) / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -2900000000000.0], t$95$2, If[LessEqual[y, -1.16e-57], t$95$1, If[LessEqual[y, -1.35e-185], N[(N[(x * t$95$3), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[y, -8.4e-237], t$95$1, If[LessEqual[y, -5.5e-290], N[(N[(x / a), $MachinePrecision] * t$95$3), $MachinePrecision], If[LessEqual[y, 4.2e+124], t$95$1, If[LessEqual[y, 2.65e+295], t$95$2, N[(N[(x / N[Exp[b], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
t_2 := \frac{{z}^{y}}{a} \cdot \frac{x}{y}\\
t_3 := \frac{{a}^{t}}{y}\\
\mathbf{if}\;y \leq -2900000000000:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -1.16 \cdot 10^{-57}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1.35 \cdot 10^{-185}:\\
\;\;\;\;\frac{x \cdot t\_3}{a}\\
\mathbf{elif}\;y \leq -8.4 \cdot 10^{-237}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -5.5 \cdot 10^{-290}:\\
\;\;\;\;\frac{x}{a} \cdot t\_3\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{+124}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.65 \cdot 10^{+295}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{e^{b}}}{y}\\
\end{array}
\end{array}
if y < -2.9e12 or 4.20000000000000023e124 < y < 2.6499999999999998e295Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum67.8%
associate-/l*65.5%
*-commutative65.5%
exp-to-pow65.5%
exp-diff58.6%
*-commutative58.6%
exp-to-pow58.6%
sub-neg58.6%
metadata-eval58.6%
Simplified58.6%
Taylor expanded in t around 0 66.7%
Taylor expanded in b around 0 76.0%
*-commutative76.0%
times-frac77.2%
Simplified77.2%
if -2.9e12 < y < -1.15999999999999996e-57 or -1.34999999999999994e-185 < y < -8.4000000000000005e-237 or -5.5e-290 < y < 4.20000000000000023e124Initial program 98.1%
associate-/l*96.9%
associate--l+96.9%
exp-sum84.6%
associate-/l*84.6%
*-commutative84.6%
exp-to-pow84.6%
exp-diff75.3%
*-commutative75.3%
exp-to-pow76.2%
sub-neg76.2%
metadata-eval76.2%
Simplified76.2%
Taylor expanded in y around 0 81.7%
associate-/r*77.8%
exp-to-pow78.7%
sub-neg78.7%
metadata-eval78.7%
Simplified78.7%
Taylor expanded in t around 0 75.1%
if -1.15999999999999996e-57 < y < -1.34999999999999994e-185Initial program 98.8%
associate-/l*98.8%
associate--l+98.8%
exp-sum98.8%
associate-/l*98.8%
*-commutative98.8%
exp-to-pow98.8%
exp-diff90.1%
*-commutative90.1%
exp-to-pow91.2%
sub-neg91.2%
metadata-eval91.2%
Simplified91.2%
Taylor expanded in y around 0 90.1%
associate-/r*90.1%
exp-to-pow91.2%
sub-neg91.2%
metadata-eval91.2%
Simplified91.2%
unpow-prod-up91.2%
unpow-191.2%
Applied egg-rr91.2%
associate-*r/91.2%
*-rgt-identity91.2%
Simplified91.2%
Taylor expanded in x around 0 91.3%
times-frac86.9%
Simplified86.9%
associate-*l/87.2%
Applied egg-rr87.2%
Taylor expanded in b around 0 87.6%
associate-/l*87.6%
Simplified87.6%
if -8.4000000000000005e-237 < y < -5.5e-290Initial program 96.6%
associate-/l*83.0%
associate--l+83.0%
exp-sum83.0%
associate-/l*83.0%
*-commutative83.0%
exp-to-pow83.0%
exp-diff83.0%
*-commutative83.0%
exp-to-pow83.9%
sub-neg83.9%
metadata-eval83.9%
Simplified83.9%
Taylor expanded in y around 0 83.0%
associate-/r*83.0%
exp-to-pow83.9%
sub-neg83.9%
metadata-eval83.9%
Simplified83.9%
unpow-prod-up84.3%
unpow-184.3%
Applied egg-rr84.3%
associate-*r/84.3%
*-rgt-identity84.3%
Simplified84.3%
Taylor expanded in x around 0 74.8%
times-frac91.3%
Simplified91.3%
Taylor expanded in b around 0 91.5%
if 2.6499999999999998e295 < y Initial program 100.0%
*-commutative100.0%
associate-/l*50.0%
associate--l+50.0%
fma-define50.0%
sub-neg50.0%
metadata-eval50.0%
Simplified50.0%
Taylor expanded in b around inf 50.0%
neg-mul-150.0%
Simplified50.0%
associate-*r/100.0%
Applied egg-rr100.0%
Taylor expanded in b around inf 100.0%
exp-neg100.0%
associate-*r/100.0%
*-rgt-identity100.0%
Simplified100.0%
Final simplification78.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* x (/ (pow z y) a)) y)) (t_2 (/ (pow a t) y)))
(if (<= t -7000.0)
(* (/ x a) t_2)
(if (<= t -4.2e-30)
(/ x (* a (* y (exp b))))
(if (<= t -5.2e-141)
t_1
(if (<= t -3e-183)
(/ (/ x (exp b)) y)
(if (<= t 2.8e-298)
t_1
(if (<= t 1.55e+16)
(/ (* x (/ (exp (- b)) y)) a)
(/ (* x t_2) a)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * (pow(z, y) / a)) / y;
double t_2 = pow(a, t) / y;
double tmp;
if (t <= -7000.0) {
tmp = (x / a) * t_2;
} else if (t <= -4.2e-30) {
tmp = x / (a * (y * exp(b)));
} else if (t <= -5.2e-141) {
tmp = t_1;
} else if (t <= -3e-183) {
tmp = (x / exp(b)) / y;
} else if (t <= 2.8e-298) {
tmp = t_1;
} else if (t <= 1.55e+16) {
tmp = (x * (exp(-b) / y)) / a;
} else {
tmp = (x * t_2) / 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x * ((z ** y) / a)) / y
t_2 = (a ** t) / y
if (t <= (-7000.0d0)) then
tmp = (x / a) * t_2
else if (t <= (-4.2d-30)) then
tmp = x / (a * (y * exp(b)))
else if (t <= (-5.2d-141)) then
tmp = t_1
else if (t <= (-3d-183)) then
tmp = (x / exp(b)) / y
else if (t <= 2.8d-298) then
tmp = t_1
else if (t <= 1.55d+16) then
tmp = (x * (exp(-b) / y)) / a
else
tmp = (x * t_2) / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * (Math.pow(z, y) / a)) / y;
double t_2 = Math.pow(a, t) / y;
double tmp;
if (t <= -7000.0) {
tmp = (x / a) * t_2;
} else if (t <= -4.2e-30) {
tmp = x / (a * (y * Math.exp(b)));
} else if (t <= -5.2e-141) {
tmp = t_1;
} else if (t <= -3e-183) {
tmp = (x / Math.exp(b)) / y;
} else if (t <= 2.8e-298) {
tmp = t_1;
} else if (t <= 1.55e+16) {
tmp = (x * (Math.exp(-b) / y)) / a;
} else {
tmp = (x * t_2) / a;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x * (math.pow(z, y) / a)) / y t_2 = math.pow(a, t) / y tmp = 0 if t <= -7000.0: tmp = (x / a) * t_2 elif t <= -4.2e-30: tmp = x / (a * (y * math.exp(b))) elif t <= -5.2e-141: tmp = t_1 elif t <= -3e-183: tmp = (x / math.exp(b)) / y elif t <= 2.8e-298: tmp = t_1 elif t <= 1.55e+16: tmp = (x * (math.exp(-b) / y)) / a else: tmp = (x * t_2) / a return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * Float64((z ^ y) / a)) / y) t_2 = Float64((a ^ t) / y) tmp = 0.0 if (t <= -7000.0) tmp = Float64(Float64(x / a) * t_2); elseif (t <= -4.2e-30) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); elseif (t <= -5.2e-141) tmp = t_1; elseif (t <= -3e-183) tmp = Float64(Float64(x / exp(b)) / y); elseif (t <= 2.8e-298) tmp = t_1; elseif (t <= 1.55e+16) tmp = Float64(Float64(x * Float64(exp(Float64(-b)) / y)) / a); else tmp = Float64(Float64(x * t_2) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x * ((z ^ y) / a)) / y; t_2 = (a ^ t) / y; tmp = 0.0; if (t <= -7000.0) tmp = (x / a) * t_2; elseif (t <= -4.2e-30) tmp = x / (a * (y * exp(b))); elseif (t <= -5.2e-141) tmp = t_1; elseif (t <= -3e-183) tmp = (x / exp(b)) / y; elseif (t <= 2.8e-298) tmp = t_1; elseif (t <= 1.55e+16) tmp = (x * (exp(-b) / y)) / a; else tmp = (x * t_2) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[(N[Power[z, y], $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t, -7000.0], N[(N[(x / a), $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[t, -4.2e-30], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -5.2e-141], t$95$1, If[LessEqual[t, -3e-183], N[(N[(x / N[Exp[b], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t, 2.8e-298], t$95$1, If[LessEqual[t, 1.55e+16], N[(N[(x * N[(N[Exp[(-b)], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[(N[(x * t$95$2), $MachinePrecision] / a), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot \frac{{z}^{y}}{a}}{y}\\
t_2 := \frac{{a}^{t}}{y}\\
\mathbf{if}\;t \leq -7000:\\
\;\;\;\;\frac{x}{a} \cdot t\_2\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{-30}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{elif}\;t \leq -5.2 \cdot 10^{-141}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -3 \cdot 10^{-183}:\\
\;\;\;\;\frac{\frac{x}{e^{b}}}{y}\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{-298}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.55 \cdot 10^{+16}:\\
\;\;\;\;\frac{x \cdot \frac{e^{-b}}{y}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot t\_2}{a}\\
\end{array}
\end{array}
if t < -7e3Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum81.4%
associate-/l*81.4%
*-commutative81.4%
exp-to-pow81.4%
exp-diff67.8%
*-commutative67.8%
exp-to-pow67.8%
sub-neg67.8%
metadata-eval67.8%
Simplified67.8%
Taylor expanded in y around 0 78.0%
associate-/r*78.0%
exp-to-pow78.0%
sub-neg78.0%
metadata-eval78.0%
Simplified78.0%
unpow-prod-up78.0%
unpow-178.0%
Applied egg-rr78.0%
associate-*r/78.0%
*-rgt-identity78.0%
Simplified78.0%
Taylor expanded in x around 0 78.0%
times-frac78.0%
Simplified78.0%
Taylor expanded in b around 0 91.7%
if -7e3 < t < -4.2000000000000004e-30Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum86.7%
associate-/l*86.7%
*-commutative86.7%
exp-to-pow86.7%
exp-diff86.7%
*-commutative86.7%
exp-to-pow86.7%
sub-neg86.7%
metadata-eval86.7%
Simplified86.7%
Taylor expanded in y around 0 80.9%
associate-/r*67.6%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in t around 0 80.9%
if -4.2000000000000004e-30 < t < -5.20000000000000022e-141 or -2.9999999999999998e-183 < t < 2.79999999999999992e-298Initial program 97.1%
associate-/l*95.8%
associate--l+95.8%
exp-sum82.5%
associate-/l*80.8%
*-commutative80.8%
exp-to-pow80.8%
exp-diff80.8%
*-commutative80.8%
exp-to-pow81.8%
sub-neg81.8%
metadata-eval81.8%
Simplified81.8%
Taylor expanded in t around 0 80.1%
Taylor expanded in b around 0 70.6%
*-commutative70.6%
times-frac73.9%
Simplified73.9%
associate-*l/83.6%
Applied egg-rr83.6%
if -5.20000000000000022e-141 < t < -2.9999999999999998e-183Initial 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 b around inf 100.0%
neg-mul-1100.0%
Simplified100.0%
associate-*r/100.0%
Applied egg-rr100.0%
Taylor expanded in b around inf 100.0%
exp-neg100.0%
associate-*r/100.0%
*-rgt-identity100.0%
Simplified100.0%
if 2.79999999999999992e-298 < t < 1.55e16Initial program 97.9%
associate-/l*94.2%
associate--l+94.2%
exp-sum80.8%
associate-/l*79.3%
*-commutative79.3%
exp-to-pow79.3%
exp-diff77.8%
*-commutative77.8%
exp-to-pow79.2%
sub-neg79.2%
metadata-eval79.2%
Simplified79.2%
Taylor expanded in y around 0 71.1%
associate-/r*66.6%
exp-to-pow67.9%
sub-neg67.9%
metadata-eval67.9%
Simplified67.9%
unpow-prod-up68.0%
unpow-168.0%
Applied egg-rr68.0%
associate-*r/68.0%
*-rgt-identity68.0%
Simplified68.0%
Taylor expanded in x around 0 73.7%
times-frac69.2%
Simplified69.2%
associate-*l/76.8%
Applied egg-rr76.8%
Taylor expanded in t around 0 78.0%
*-commutative78.0%
associate-/r*78.0%
rec-exp78.0%
Simplified78.0%
if 1.55e16 < t Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum70.8%
associate-/l*70.8%
*-commutative70.8%
exp-to-pow70.8%
exp-diff47.9%
*-commutative47.9%
exp-to-pow47.9%
sub-neg47.9%
metadata-eval47.9%
Simplified47.9%
Taylor expanded in y around 0 58.5%
associate-/r*58.5%
exp-to-pow58.5%
sub-neg58.5%
metadata-eval58.5%
Simplified58.5%
unpow-prod-up58.5%
unpow-158.5%
Applied egg-rr58.5%
associate-*r/58.5%
*-rgt-identity58.5%
Simplified58.5%
Taylor expanded in x around 0 48.0%
times-frac39.7%
Simplified39.7%
associate-*l/58.5%
Applied egg-rr58.5%
Taylor expanded in b around 0 71.3%
associate-/l*71.3%
Simplified71.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (/ x a) (/ (pow a t) y))))
(if (<= b -7.2e+109)
(/
(* x (+ 1.0 (* b (+ (* b (+ 0.5 (* b -0.16666666666666666))) -1.0))))
y)
(if (<= b -1.6e+80)
t_1
(if (<= b -8600.0)
(/ (/ x (exp b)) y)
(if (<= b -4.4e-89)
t_1
(if (<= b -9.5e-114)
(* x (/ 1.0 (* y a)))
(if (<= b 2e-82) t_1 (/ x (* a (* y (exp b))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / a) * (pow(a, t) / y);
double tmp;
if (b <= -7.2e+109) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -1.6e+80) {
tmp = t_1;
} else if (b <= -8600.0) {
tmp = (x / exp(b)) / y;
} else if (b <= -4.4e-89) {
tmp = t_1;
} else if (b <= -9.5e-114) {
tmp = x * (1.0 / (y * a));
} else if (b <= 2e-82) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = (x / a) * ((a ** t) / y)
if (b <= (-7.2d+109)) then
tmp = (x * (1.0d0 + (b * ((b * (0.5d0 + (b * (-0.16666666666666666d0)))) + (-1.0d0))))) / y
else if (b <= (-1.6d+80)) then
tmp = t_1
else if (b <= (-8600.0d0)) then
tmp = (x / exp(b)) / y
else if (b <= (-4.4d-89)) then
tmp = t_1
else if (b <= (-9.5d-114)) then
tmp = x * (1.0d0 / (y * a))
else if (b <= 2d-82) then
tmp = t_1
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 t_1 = (x / a) * (Math.pow(a, t) / y);
double tmp;
if (b <= -7.2e+109) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -1.6e+80) {
tmp = t_1;
} else if (b <= -8600.0) {
tmp = (x / Math.exp(b)) / y;
} else if (b <= -4.4e-89) {
tmp = t_1;
} else if (b <= -9.5e-114) {
tmp = x * (1.0 / (y * a));
} else if (b <= 2e-82) {
tmp = t_1;
} else {
tmp = x / (a * (y * Math.exp(b)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x / a) * (math.pow(a, t) / y) tmp = 0 if b <= -7.2e+109: tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y elif b <= -1.6e+80: tmp = t_1 elif b <= -8600.0: tmp = (x / math.exp(b)) / y elif b <= -4.4e-89: tmp = t_1 elif b <= -9.5e-114: tmp = x * (1.0 / (y * a)) elif b <= 2e-82: tmp = t_1 else: tmp = x / (a * (y * math.exp(b))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x / a) * Float64((a ^ t) / y)) tmp = 0.0 if (b <= -7.2e+109) tmp = Float64(Float64(x * Float64(1.0 + Float64(b * Float64(Float64(b * Float64(0.5 + Float64(b * -0.16666666666666666))) + -1.0)))) / y); elseif (b <= -1.6e+80) tmp = t_1; elseif (b <= -8600.0) tmp = Float64(Float64(x / exp(b)) / y); elseif (b <= -4.4e-89) tmp = t_1; elseif (b <= -9.5e-114) tmp = Float64(x * Float64(1.0 / Float64(y * a))); elseif (b <= 2e-82) tmp = t_1; else tmp = Float64(x / Float64(a * Float64(y * exp(b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x / a) * ((a ^ t) / y); tmp = 0.0; if (b <= -7.2e+109) tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y; elseif (b <= -1.6e+80) tmp = t_1; elseif (b <= -8600.0) tmp = (x / exp(b)) / y; elseif (b <= -4.4e-89) tmp = t_1; elseif (b <= -9.5e-114) tmp = x * (1.0 / (y * a)); elseif (b <= 2e-82) tmp = t_1; else tmp = x / (a * (y * exp(b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x / a), $MachinePrecision] * N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.2e+109], N[(N[(x * N[(1.0 + N[(b * N[(N[(b * N[(0.5 + N[(b * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.6e+80], t$95$1, If[LessEqual[b, -8600.0], N[(N[(x / N[Exp[b], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -4.4e-89], t$95$1, If[LessEqual[b, -9.5e-114], N[(x * N[(1.0 / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2e-82], t$95$1, N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a} \cdot \frac{{a}^{t}}{y}\\
\mathbf{if}\;b \leq -7.2 \cdot 10^{+109}:\\
\;\;\;\;\frac{x \cdot \left(1 + b \cdot \left(b \cdot \left(0.5 + b \cdot -0.16666666666666666\right) + -1\right)\right)}{y}\\
\mathbf{elif}\;b \leq -1.6 \cdot 10^{+80}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -8600:\\
\;\;\;\;\frac{\frac{x}{e^{b}}}{y}\\
\mathbf{elif}\;b \leq -4.4 \cdot 10^{-89}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -9.5 \cdot 10^{-114}:\\
\;\;\;\;x \cdot \frac{1}{y \cdot a}\\
\mathbf{elif}\;b \leq 2 \cdot 10^{-82}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\end{array}
\end{array}
if b < -7.2e109Initial program 100.0%
*-commutative100.0%
associate-/l*87.5%
associate--l+87.5%
fma-define87.5%
sub-neg87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in b around inf 81.3%
neg-mul-181.3%
Simplified81.3%
Taylor expanded in b around 0 74.4%
Taylor expanded in y around 0 83.9%
Taylor expanded in x around 0 87.9%
Taylor expanded in x around 0 93.8%
if -7.2e109 < b < -1.59999999999999995e80 or -8600 < b < -4.40000000000000024e-89 or -9.49999999999999958e-114 < b < 2e-82Initial program 97.5%
associate-/l*95.5%
associate--l+95.5%
exp-sum84.7%
associate-/l*83.0%
*-commutative83.0%
exp-to-pow83.0%
exp-diff79.7%
*-commutative79.7%
exp-to-pow80.9%
sub-neg80.9%
metadata-eval80.9%
Simplified80.9%
Taylor expanded in y around 0 65.6%
associate-/r*65.6%
exp-to-pow66.7%
sub-neg66.7%
metadata-eval66.7%
Simplified66.7%
unpow-prod-up66.8%
unpow-166.8%
Applied egg-rr66.8%
associate-*r/66.8%
*-rgt-identity66.8%
Simplified66.8%
Taylor expanded in x around 0 64.0%
times-frac64.9%
Simplified64.9%
Taylor expanded in b around 0 68.2%
if -1.59999999999999995e80 < b < -8600Initial program 100.0%
*-commutative100.0%
associate-/l*93.3%
associate--l+93.3%
fma-define93.3%
sub-neg93.3%
metadata-eval93.3%
Simplified93.3%
Taylor expanded in b around inf 66.9%
neg-mul-166.9%
Simplified66.9%
associate-*r/73.8%
Applied egg-rr73.8%
Taylor expanded in b around inf 73.8%
exp-neg73.8%
associate-*r/73.8%
*-rgt-identity73.8%
Simplified73.8%
if -4.40000000000000024e-89 < b < -9.49999999999999958e-114Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum75.0%
associate-/l*75.0%
*-commutative75.0%
exp-to-pow75.0%
exp-diff75.0%
*-commutative75.0%
exp-to-pow75.0%
sub-neg75.0%
metadata-eval75.0%
Simplified75.0%
Taylor expanded in t around 0 100.0%
Taylor expanded in b around 0 100.0%
*-commutative100.0%
times-frac100.0%
Simplified100.0%
Taylor expanded in y around 0 75.4%
div-inv75.4%
*-commutative75.4%
Applied egg-rr75.4%
if 2e-82 < b Initial program 99.8%
associate-/l*98.5%
associate--l+98.5%
exp-sum73.9%
associate-/l*73.9%
*-commutative73.9%
exp-to-pow73.9%
exp-diff60.8%
*-commutative60.8%
exp-to-pow60.9%
sub-neg60.9%
metadata-eval60.9%
Simplified60.9%
Taylor expanded in y around 0 71.1%
associate-/r*63.9%
exp-to-pow64.0%
sub-neg64.0%
metadata-eval64.0%
Simplified64.0%
Taylor expanded in t around 0 75.9%
Final simplification75.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (/ x (exp b)) y)))
(if (<= b -280.0)
t_1
(if (<= b -1.15e-59)
(/ (/ x a) y)
(if (<= b -1.05e-167)
(* (/ x y) (/ 1.0 a))
(if (<= b -1.08e-263)
(/ (- x (* b (* b (- (/ x b) (* x 0.5))))) y)
(if (<= b 8.8e-39) (/ x (* y 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 <= -280.0) {
tmp = t_1;
} else if (b <= -1.15e-59) {
tmp = (x / a) / y;
} else if (b <= -1.05e-167) {
tmp = (x / y) * (1.0 / a);
} else if (b <= -1.08e-263) {
tmp = (x - (b * (b * ((x / b) - (x * 0.5))))) / y;
} else if (b <= 8.8e-39) {
tmp = x / (y * a);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = (x / exp(b)) / y
if (b <= (-280.0d0)) then
tmp = t_1
else if (b <= (-1.15d-59)) then
tmp = (x / a) / y
else if (b <= (-1.05d-167)) then
tmp = (x / y) * (1.0d0 / a)
else if (b <= (-1.08d-263)) then
tmp = (x - (b * (b * ((x / b) - (x * 0.5d0))))) / y
else if (b <= 8.8d-39) then
tmp = x / (y * a)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / Math.exp(b)) / y;
double tmp;
if (b <= -280.0) {
tmp = t_1;
} else if (b <= -1.15e-59) {
tmp = (x / a) / y;
} else if (b <= -1.05e-167) {
tmp = (x / y) * (1.0 / a);
} else if (b <= -1.08e-263) {
tmp = (x - (b * (b * ((x / b) - (x * 0.5))))) / y;
} else if (b <= 8.8e-39) {
tmp = x / (y * 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 <= -280.0: tmp = t_1 elif b <= -1.15e-59: tmp = (x / a) / y elif b <= -1.05e-167: tmp = (x / y) * (1.0 / a) elif b <= -1.08e-263: tmp = (x - (b * (b * ((x / b) - (x * 0.5))))) / y elif b <= 8.8e-39: tmp = x / (y * a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x / exp(b)) / y) tmp = 0.0 if (b <= -280.0) tmp = t_1; elseif (b <= -1.15e-59) tmp = Float64(Float64(x / a) / y); elseif (b <= -1.05e-167) tmp = Float64(Float64(x / y) * Float64(1.0 / a)); elseif (b <= -1.08e-263) tmp = Float64(Float64(x - Float64(b * Float64(b * Float64(Float64(x / b) - Float64(x * 0.5))))) / y); elseif (b <= 8.8e-39) tmp = Float64(x / Float64(y * 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 <= -280.0) tmp = t_1; elseif (b <= -1.15e-59) tmp = (x / a) / y; elseif (b <= -1.05e-167) tmp = (x / y) * (1.0 / a); elseif (b <= -1.08e-263) tmp = (x - (b * (b * ((x / b) - (x * 0.5))))) / y; elseif (b <= 8.8e-39) tmp = x / (y * a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x / N[Exp[b], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[b, -280.0], t$95$1, If[LessEqual[b, -1.15e-59], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.05e-167], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.08e-263], N[(N[(x - N[(b * N[(b * N[(N[(x / b), $MachinePrecision] - N[(x * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 8.8e-39], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{x}{e^{b}}}{y}\\
\mathbf{if}\;b \leq -280:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.15 \cdot 10^{-59}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{elif}\;b \leq -1.05 \cdot 10^{-167}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{elif}\;b \leq -1.08 \cdot 10^{-263}:\\
\;\;\;\;\frac{x - b \cdot \left(b \cdot \left(\frac{x}{b} - x \cdot 0.5\right)\right)}{y}\\
\mathbf{elif}\;b \leq 8.8 \cdot 10^{-39}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -280 or 8.80000000000000003e-39 < b Initial program 100.0%
*-commutative100.0%
associate-/l*87.8%
associate--l+87.8%
fma-define87.8%
sub-neg87.8%
metadata-eval87.8%
Simplified87.8%
Taylor expanded in b around inf 68.7%
neg-mul-168.7%
Simplified68.7%
associate-*r/78.1%
Applied egg-rr78.1%
Taylor expanded in b around inf 78.1%
exp-neg78.1%
associate-*r/78.1%
*-rgt-identity78.1%
Simplified78.1%
if -280 < b < -1.1499999999999999e-59Initial program 95.9%
associate-/l*95.9%
associate--l+95.9%
exp-sum86.8%
associate-/l*86.8%
*-commutative86.8%
exp-to-pow86.8%
exp-diff87.0%
*-commutative87.0%
exp-to-pow90.3%
sub-neg90.3%
metadata-eval90.3%
Simplified90.3%
Taylor expanded in t around 0 74.4%
Taylor expanded in b around 0 73.4%
*-commutative73.4%
times-frac64.1%
Simplified64.1%
associate-*l/81.9%
Applied egg-rr81.9%
Taylor expanded in y around 0 64.8%
if -1.1499999999999999e-59 < b < -1.05000000000000009e-167Initial program 99.1%
associate-/l*99.1%
associate--l+99.1%
exp-sum84.8%
associate-/l*84.8%
*-commutative84.8%
exp-to-pow84.8%
exp-diff84.8%
*-commutative84.8%
exp-to-pow85.6%
sub-neg85.6%
metadata-eval85.6%
Simplified85.6%
Taylor expanded in t around 0 72.4%
Taylor expanded in b around 0 72.4%
*-commutative72.4%
times-frac72.0%
Simplified72.0%
Taylor expanded in y around 0 53.7%
if -1.05000000000000009e-167 < b < -1.07999999999999998e-263Initial program 94.9%
*-commutative94.9%
associate-/l*99.0%
associate--l+99.0%
fma-define99.0%
sub-neg99.0%
metadata-eval99.0%
Simplified99.0%
Taylor expanded in b around inf 8.2%
neg-mul-18.2%
Simplified8.2%
Taylor expanded in b around 0 8.2%
Taylor expanded in y around 0 8.2%
Taylor expanded in b around 0 8.2%
neg-mul-18.2%
+-commutative8.2%
associate-*r*8.2%
neg-mul-18.2%
distribute-rgt-out8.2%
*-commutative8.2%
Simplified8.2%
Taylor expanded in b around inf 38.7%
if -1.07999999999999998e-263 < b < 8.80000000000000003e-39Initial program 97.9%
associate-/l*92.6%
associate--l+92.6%
exp-sum86.2%
associate-/l*84.6%
*-commutative84.6%
exp-to-pow84.6%
exp-diff84.6%
*-commutative84.6%
exp-to-pow86.0%
sub-neg86.0%
metadata-eval86.0%
Simplified86.0%
Taylor expanded in t around 0 74.8%
Taylor expanded in b around 0 74.8%
*-commutative74.8%
times-frac72.0%
Simplified72.0%
Taylor expanded in y around 0 51.9%
Final simplification65.7%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (* y (exp b)))) (if (<= x 2.45e-194) (/ (/ x t_1) a) (/ x (* a t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * exp(b);
double tmp;
if (x <= 2.45e-194) {
tmp = (x / t_1) / a;
} else {
tmp = x / (a * 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 = y * exp(b)
if (x <= 2.45d-194) then
tmp = (x / t_1) / a
else
tmp = x / (a * 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 = y * Math.exp(b);
double tmp;
if (x <= 2.45e-194) {
tmp = (x / t_1) / a;
} else {
tmp = x / (a * t_1);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y * math.exp(b) tmp = 0 if x <= 2.45e-194: tmp = (x / t_1) / a else: tmp = x / (a * t_1) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y * exp(b)) tmp = 0.0 if (x <= 2.45e-194) tmp = Float64(Float64(x / t_1) / a); else tmp = Float64(x / Float64(a * t_1)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y * exp(b); tmp = 0.0; if (x <= 2.45e-194) tmp = (x / t_1) / a; else tmp = x / (a * t_1); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, 2.45e-194], N[(N[(x / t$95$1), $MachinePrecision] / a), $MachinePrecision], N[(x / N[(a * t$95$1), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot e^{b}\\
\mathbf{if}\;x \leq 2.45 \cdot 10^{-194}:\\
\;\;\;\;\frac{\frac{x}{t\_1}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot t\_1}\\
\end{array}
\end{array}
if x < 2.45000000000000002e-194Initial program 98.4%
associate-/l*96.3%
associate--l+96.3%
exp-sum78.1%
associate-/l*76.8%
*-commutative76.8%
exp-to-pow76.8%
exp-diff67.1%
*-commutative67.1%
exp-to-pow67.6%
sub-neg67.6%
metadata-eval67.6%
Simplified67.6%
Taylor expanded in y around 0 65.0%
associate-/r*63.0%
exp-to-pow63.6%
sub-neg63.6%
metadata-eval63.6%
Simplified63.6%
unpow-prod-up63.6%
unpow-163.6%
Applied egg-rr63.6%
associate-*r/63.6%
*-rgt-identity63.6%
Simplified63.6%
Taylor expanded in x around 0 64.1%
times-frac63.4%
Simplified63.4%
associate-*l/69.2%
Applied egg-rr69.2%
Taylor expanded in t around 0 60.7%
if 2.45000000000000002e-194 < x Initial program 99.4%
associate-/l*99.4%
associate--l+99.4%
exp-sum83.7%
associate-/l*83.7%
*-commutative83.7%
exp-to-pow83.7%
exp-diff78.8%
*-commutative78.8%
exp-to-pow79.4%
sub-neg79.4%
metadata-eval79.4%
Simplified79.4%
Taylor expanded in y around 0 78.2%
associate-/r*72.4%
exp-to-pow72.9%
sub-neg72.9%
metadata-eval72.9%
Simplified72.9%
Taylor expanded in t around 0 66.7%
(FPCore (x y z t a b) :precision binary64 (/ x (* a (* y (exp b)))))
double code(double x, double y, double z, double t, double a, double b) {
return x / (a * (y * exp(b)));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / (a * (y * exp(b)))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / (a * (y * Math.exp(b)));
}
def code(x, y, z, t, a, b): return x / (a * (y * math.exp(b)))
function code(x, y, z, t, a, b) return Float64(x / Float64(a * Float64(y * exp(b)))) end
function tmp = code(x, y, z, t, a, b) tmp = x / (a * (y * exp(b))); end
code[x_, y_, z_, t_, a_, b_] := N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{a \cdot \left(y \cdot e^{b}\right)}
\end{array}
Initial program 98.8%
associate-/l*97.5%
associate--l+97.5%
exp-sum80.3%
associate-/l*79.5%
*-commutative79.5%
exp-to-pow79.5%
exp-diff71.7%
*-commutative71.7%
exp-to-pow72.3%
sub-neg72.3%
metadata-eval72.3%
Simplified72.3%
Taylor expanded in y around 0 70.3%
associate-/r*66.7%
exp-to-pow67.3%
sub-neg67.3%
metadata-eval67.3%
Simplified67.3%
Taylor expanded in t around 0 62.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (/ x a) y)) (t_2 (/ x (* y a))))
(if (<= b -1.32e+128)
(/ (* x (+ 1.0 (* b (+ -1.0 (* b 0.5))))) y)
(if (<= b -8.2e-17)
(/ (- (/ x y) (* x (/ b y))) a)
(if (<= b -5e-67)
t_1
(if (<= b -4e-163)
(* (/ x y) (/ 1.0 a))
(if (<= b 5e-209)
t_2
(if (<= b 8.1e+65)
t_1
(if (<= b 1.6e+245) t_2 (/ (/ x y) a))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x / a) / y;
double t_2 = x / (y * a);
double tmp;
if (b <= -1.32e+128) {
tmp = (x * (1.0 + (b * (-1.0 + (b * 0.5))))) / y;
} else if (b <= -8.2e-17) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= -5e-67) {
tmp = t_1;
} else if (b <= -4e-163) {
tmp = (x / y) * (1.0 / a);
} else if (b <= 5e-209) {
tmp = t_2;
} else if (b <= 8.1e+65) {
tmp = t_1;
} else if (b <= 1.6e+245) {
tmp = t_2;
} 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x / a) / y
t_2 = x / (y * a)
if (b <= (-1.32d+128)) then
tmp = (x * (1.0d0 + (b * ((-1.0d0) + (b * 0.5d0))))) / y
else if (b <= (-8.2d-17)) then
tmp = ((x / y) - (x * (b / y))) / a
else if (b <= (-5d-67)) then
tmp = t_1
else if (b <= (-4d-163)) then
tmp = (x / y) * (1.0d0 / a)
else if (b <= 5d-209) then
tmp = t_2
else if (b <= 8.1d+65) then
tmp = t_1
else if (b <= 1.6d+245) then
tmp = t_2
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 t_1 = (x / a) / y;
double t_2 = x / (y * a);
double tmp;
if (b <= -1.32e+128) {
tmp = (x * (1.0 + (b * (-1.0 + (b * 0.5))))) / y;
} else if (b <= -8.2e-17) {
tmp = ((x / y) - (x * (b / y))) / a;
} else if (b <= -5e-67) {
tmp = t_1;
} else if (b <= -4e-163) {
tmp = (x / y) * (1.0 / a);
} else if (b <= 5e-209) {
tmp = t_2;
} else if (b <= 8.1e+65) {
tmp = t_1;
} else if (b <= 1.6e+245) {
tmp = t_2;
} else {
tmp = (x / y) / a;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x / a) / y t_2 = x / (y * a) tmp = 0 if b <= -1.32e+128: tmp = (x * (1.0 + (b * (-1.0 + (b * 0.5))))) / y elif b <= -8.2e-17: tmp = ((x / y) - (x * (b / y))) / a elif b <= -5e-67: tmp = t_1 elif b <= -4e-163: tmp = (x / y) * (1.0 / a) elif b <= 5e-209: tmp = t_2 elif b <= 8.1e+65: tmp = t_1 elif b <= 1.6e+245: tmp = t_2 else: tmp = (x / y) / a return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x / a) / y) t_2 = Float64(x / Float64(y * a)) tmp = 0.0 if (b <= -1.32e+128) tmp = Float64(Float64(x * Float64(1.0 + Float64(b * Float64(-1.0 + Float64(b * 0.5))))) / y); elseif (b <= -8.2e-17) tmp = Float64(Float64(Float64(x / y) - Float64(x * Float64(b / y))) / a); elseif (b <= -5e-67) tmp = t_1; elseif (b <= -4e-163) tmp = Float64(Float64(x / y) * Float64(1.0 / a)); elseif (b <= 5e-209) tmp = t_2; elseif (b <= 8.1e+65) tmp = t_1; elseif (b <= 1.6e+245) tmp = t_2; else tmp = Float64(Float64(x / y) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x / a) / y; t_2 = x / (y * a); tmp = 0.0; if (b <= -1.32e+128) tmp = (x * (1.0 + (b * (-1.0 + (b * 0.5))))) / y; elseif (b <= -8.2e-17) tmp = ((x / y) - (x * (b / y))) / a; elseif (b <= -5e-67) tmp = t_1; elseif (b <= -4e-163) tmp = (x / y) * (1.0 / a); elseif (b <= 5e-209) tmp = t_2; elseif (b <= 8.1e+65) tmp = t_1; elseif (b <= 1.6e+245) tmp = t_2; else tmp = (x / y) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.32e+128], N[(N[(x * N[(1.0 + N[(b * N[(-1.0 + N[(b * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -8.2e-17], N[(N[(N[(x / y), $MachinePrecision] - N[(x * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -5e-67], t$95$1, If[LessEqual[b, -4e-163], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5e-209], t$95$2, If[LessEqual[b, 8.1e+65], t$95$1, If[LessEqual[b, 1.6e+245], t$95$2, N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{x}{a}}{y}\\
t_2 := \frac{x}{y \cdot a}\\
\mathbf{if}\;b \leq -1.32 \cdot 10^{+128}:\\
\;\;\;\;\frac{x \cdot \left(1 + b \cdot \left(-1 + b \cdot 0.5\right)\right)}{y}\\
\mathbf{elif}\;b \leq -8.2 \cdot 10^{-17}:\\
\;\;\;\;\frac{\frac{x}{y} - x \cdot \frac{b}{y}}{a}\\
\mathbf{elif}\;b \leq -5 \cdot 10^{-67}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -4 \cdot 10^{-163}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{elif}\;b \leq 5 \cdot 10^{-209}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 8.1 \cdot 10^{+65}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.6 \cdot 10^{+245}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\end{array}
\end{array}
if b < -1.31999999999999991e128Initial program 100.0%
*-commutative100.0%
associate-/l*86.0%
associate--l+86.0%
fma-define86.0%
sub-neg86.0%
metadata-eval86.0%
Simplified86.0%
Taylor expanded in b around inf 79.1%
neg-mul-179.1%
Simplified79.1%
Taylor expanded in b around 0 78.0%
Taylor expanded in y around 0 86.4%
Taylor expanded in b around 0 77.4%
neg-mul-177.4%
+-commutative77.4%
associate-*r*77.4%
neg-mul-177.4%
distribute-rgt-out77.4%
*-commutative77.4%
Simplified77.4%
Taylor expanded in x around 0 88.6%
if -1.31999999999999991e128 < b < -8.2000000000000001e-17Initial program 99.6%
associate-/l*99.6%
associate--l+99.6%
exp-sum80.2%
associate-/l*80.2%
*-commutative80.2%
exp-to-pow80.2%
exp-diff63.5%
*-commutative63.5%
exp-to-pow63.9%
sub-neg63.9%
metadata-eval63.9%
Simplified63.9%
Taylor expanded in y around 0 64.0%
associate-/r*61.2%
exp-to-pow61.5%
sub-neg61.5%
metadata-eval61.5%
Simplified61.5%
unpow-prod-up61.5%
unpow-161.5%
Applied egg-rr61.5%
associate-*r/61.5%
*-rgt-identity61.5%
Simplified61.5%
Taylor expanded in x around 0 64.3%
times-frac55.9%
Simplified55.9%
associate-*l/64.3%
Applied egg-rr64.3%
Taylor expanded in t around 0 64.6%
*-commutative64.6%
associate-/r*64.7%
rec-exp64.7%
Simplified64.7%
Taylor expanded in b around 0 27.5%
+-commutative27.5%
mul-1-neg27.5%
unsub-neg27.5%
*-commutative27.5%
associate-/l*32.8%
Simplified32.8%
if -8.2000000000000001e-17 < b < -4.9999999999999999e-67 or 5.0000000000000005e-209 < b < 8.1000000000000001e65Initial program 98.3%
associate-/l*95.3%
associate--l+95.3%
exp-sum79.5%
associate-/l*77.7%
*-commutative77.7%
exp-to-pow77.7%
exp-diff72.5%
*-commutative72.5%
exp-to-pow73.7%
sub-neg73.7%
metadata-eval73.7%
Simplified73.7%
Taylor expanded in t around 0 60.7%
Taylor expanded in b around 0 59.2%
*-commutative59.2%
times-frac59.3%
Simplified59.3%
associate-*l/72.7%
Applied egg-rr72.7%
Taylor expanded in y around 0 42.2%
if -4.9999999999999999e-67 < b < -3.99999999999999969e-163Initial program 99.6%
associate-/l*99.6%
associate--l+99.6%
exp-sum82.9%
associate-/l*82.9%
*-commutative82.9%
exp-to-pow82.9%
exp-diff82.9%
*-commutative82.9%
exp-to-pow83.2%
sub-neg83.2%
metadata-eval83.2%
Simplified83.2%
Taylor expanded in t around 0 73.3%
Taylor expanded in b around 0 73.3%
*-commutative73.3%
times-frac72.8%
Simplified72.8%
Taylor expanded in y around 0 56.7%
if -3.99999999999999969e-163 < b < 5.0000000000000005e-209 or 8.1000000000000001e65 < b < 1.60000000000000012e245Initial program 97.7%
associate-/l*95.8%
associate--l+95.8%
exp-sum82.3%
associate-/l*81.1%
*-commutative81.1%
exp-to-pow81.1%
exp-diff78.7%
*-commutative78.7%
exp-to-pow79.4%
sub-neg79.4%
metadata-eval79.4%
Simplified79.4%
Taylor expanded in t around 0 69.7%
Taylor expanded in b around 0 57.9%
*-commutative57.9%
times-frac60.5%
Simplified60.5%
Taylor expanded in y around 0 38.2%
if 1.60000000000000012e245 < b Initial 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 75.1%
Taylor expanded in b around 0 31.8%
*-commutative31.8%
times-frac31.8%
Simplified31.8%
Taylor expanded in y around 0 27.2%
un-div-inv27.2%
Applied egg-rr27.2%
Final simplification47.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* y a))) (t_2 (/ (/ x a) y)))
(if (<= b -1.72e+165)
(/ (+ x (* b (* x (* b 0.5)))) y)
(if (<= b -1.26e-65)
t_2
(if (<= b -2e-161)
(* (/ x y) (/ 1.0 a))
(if (<= b 7e-206)
t_1
(if (<= b 2e+123) t_2 (if (<= b 1.55e+245) t_1 (/ (/ x y) a)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y * a);
double t_2 = (x / a) / y;
double tmp;
if (b <= -1.72e+165) {
tmp = (x + (b * (x * (b * 0.5)))) / y;
} else if (b <= -1.26e-65) {
tmp = t_2;
} else if (b <= -2e-161) {
tmp = (x / y) * (1.0 / a);
} else if (b <= 7e-206) {
tmp = t_1;
} else if (b <= 2e+123) {
tmp = t_2;
} else if (b <= 1.55e+245) {
tmp = t_1;
} 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x / (y * a)
t_2 = (x / a) / y
if (b <= (-1.72d+165)) then
tmp = (x + (b * (x * (b * 0.5d0)))) / y
else if (b <= (-1.26d-65)) then
tmp = t_2
else if (b <= (-2d-161)) then
tmp = (x / y) * (1.0d0 / a)
else if (b <= 7d-206) then
tmp = t_1
else if (b <= 2d+123) then
tmp = t_2
else if (b <= 1.55d+245) then
tmp = t_1
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 t_1 = x / (y * a);
double t_2 = (x / a) / y;
double tmp;
if (b <= -1.72e+165) {
tmp = (x + (b * (x * (b * 0.5)))) / y;
} else if (b <= -1.26e-65) {
tmp = t_2;
} else if (b <= -2e-161) {
tmp = (x / y) * (1.0 / a);
} else if (b <= 7e-206) {
tmp = t_1;
} else if (b <= 2e+123) {
tmp = t_2;
} else if (b <= 1.55e+245) {
tmp = t_1;
} else {
tmp = (x / y) / a;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (y * a) t_2 = (x / a) / y tmp = 0 if b <= -1.72e+165: tmp = (x + (b * (x * (b * 0.5)))) / y elif b <= -1.26e-65: tmp = t_2 elif b <= -2e-161: tmp = (x / y) * (1.0 / a) elif b <= 7e-206: tmp = t_1 elif b <= 2e+123: tmp = t_2 elif b <= 1.55e+245: tmp = t_1 else: tmp = (x / y) / a return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y * a)) t_2 = Float64(Float64(x / a) / y) tmp = 0.0 if (b <= -1.72e+165) tmp = Float64(Float64(x + Float64(b * Float64(x * Float64(b * 0.5)))) / y); elseif (b <= -1.26e-65) tmp = t_2; elseif (b <= -2e-161) tmp = Float64(Float64(x / y) * Float64(1.0 / a)); elseif (b <= 7e-206) tmp = t_1; elseif (b <= 2e+123) tmp = t_2; elseif (b <= 1.55e+245) tmp = t_1; else tmp = Float64(Float64(x / y) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (y * a); t_2 = (x / a) / y; tmp = 0.0; if (b <= -1.72e+165) tmp = (x + (b * (x * (b * 0.5)))) / y; elseif (b <= -1.26e-65) tmp = t_2; elseif (b <= -2e-161) tmp = (x / y) * (1.0 / a); elseif (b <= 7e-206) tmp = t_1; elseif (b <= 2e+123) tmp = t_2; elseif (b <= 1.55e+245) tmp = t_1; else tmp = (x / y) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[b, -1.72e+165], N[(N[(x + N[(b * N[(x * N[(b * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.26e-65], t$95$2, If[LessEqual[b, -2e-161], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7e-206], t$95$1, If[LessEqual[b, 2e+123], t$95$2, If[LessEqual[b, 1.55e+245], t$95$1, N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y \cdot a}\\
t_2 := \frac{\frac{x}{a}}{y}\\
\mathbf{if}\;b \leq -1.72 \cdot 10^{+165}:\\
\;\;\;\;\frac{x + b \cdot \left(x \cdot \left(b \cdot 0.5\right)\right)}{y}\\
\mathbf{elif}\;b \leq -1.26 \cdot 10^{-65}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -2 \cdot 10^{-161}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{elif}\;b \leq 7 \cdot 10^{-206}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 2 \cdot 10^{+123}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 1.55 \cdot 10^{+245}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\end{array}
\end{array}
if b < -1.72e165Initial program 100.0%
*-commutative100.0%
associate-/l*88.2%
associate--l+88.2%
fma-define88.2%
sub-neg88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in b around inf 82.4%
neg-mul-182.4%
Simplified82.4%
Taylor expanded in b around 0 85.9%
Taylor expanded in y around 0 88.6%
Taylor expanded in b around 0 85.7%
neg-mul-185.7%
+-commutative85.7%
associate-*r*85.7%
neg-mul-185.7%
distribute-rgt-out85.7%
*-commutative85.7%
Simplified85.7%
Taylor expanded in b around inf 85.7%
associate-*r*85.7%
*-commutative85.7%
*-commutative85.7%
Simplified85.7%
if -1.72e165 < b < -1.26e-65 or 6.99999999999999979e-206 < b < 1.99999999999999996e123Initial program 99.0%
associate-/l*97.5%
associate--l+97.5%
exp-sum78.5%
associate-/l*77.6%
*-commutative77.6%
exp-to-pow77.6%
exp-diff68.6%
*-commutative68.6%
exp-to-pow69.4%
sub-neg69.4%
metadata-eval69.4%
Simplified69.4%
Taylor expanded in t around 0 62.8%
Taylor expanded in b around 0 63.1%
*-commutative63.1%
times-frac62.2%
Simplified62.2%
associate-*l/73.6%
Applied egg-rr73.6%
Taylor expanded in y around 0 37.0%
if -1.26e-65 < b < -2.00000000000000006e-161Initial program 99.6%
associate-/l*99.6%
associate--l+99.6%
exp-sum82.9%
associate-/l*82.9%
*-commutative82.9%
exp-to-pow82.9%
exp-diff82.9%
*-commutative82.9%
exp-to-pow83.2%
sub-neg83.2%
metadata-eval83.2%
Simplified83.2%
Taylor expanded in t around 0 73.3%
Taylor expanded in b around 0 73.3%
*-commutative73.3%
times-frac72.8%
Simplified72.8%
Taylor expanded in y around 0 56.7%
if -2.00000000000000006e-161 < b < 6.99999999999999979e-206 or 1.99999999999999996e123 < b < 1.5499999999999999e245Initial program 97.4%
associate-/l*95.2%
associate--l+95.2%
exp-sum84.3%
associate-/l*82.9%
*-commutative82.9%
exp-to-pow82.9%
exp-diff81.5%
*-commutative81.5%
exp-to-pow82.4%
sub-neg82.4%
metadata-eval82.4%
Simplified82.4%
Taylor expanded in t around 0 71.4%
Taylor expanded in b around 0 59.4%
*-commutative59.4%
times-frac63.7%
Simplified63.7%
Taylor expanded in y around 0 41.1%
if 1.5499999999999999e245 < b Initial 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 75.1%
Taylor expanded in b around 0 31.8%
*-commutative31.8%
times-frac31.8%
Simplified31.8%
Taylor expanded in y around 0 27.2%
un-div-inv27.2%
Applied egg-rr27.2%
Final simplification45.3%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.1e-187)
(/
(*
x
(-
(/ 1.0 y)
(*
b
(+
(/ 1.0 y)
(* b (- (* 0.5 (/ -1.0 y)) (* -0.16666666666666666 (/ b y))))))))
a)
(if (<= b -1.55e-266)
(/
(+ x (* b (- (* b (* b (* x (- (/ 0.5 b) 0.16666666666666666)))) x)))
y)
(/ x (* y a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.1e-187) {
tmp = (x * ((1.0 / y) - (b * ((1.0 / y) + (b * ((0.5 * (-1.0 / y)) - (-0.16666666666666666 * (b / y)))))))) / a;
} else if (b <= -1.55e-266) {
tmp = (x + (b * ((b * (b * (x * ((0.5 / b) - 0.16666666666666666)))) - x))) / 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 (b <= (-1.1d-187)) then
tmp = (x * ((1.0d0 / y) - (b * ((1.0d0 / y) + (b * ((0.5d0 * ((-1.0d0) / y)) - ((-0.16666666666666666d0) * (b / y)))))))) / a
else if (b <= (-1.55d-266)) then
tmp = (x + (b * ((b * (b * (x * ((0.5d0 / b) - 0.16666666666666666d0)))) - x))) / 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 (b <= -1.1e-187) {
tmp = (x * ((1.0 / y) - (b * ((1.0 / y) + (b * ((0.5 * (-1.0 / y)) - (-0.16666666666666666 * (b / y)))))))) / a;
} else if (b <= -1.55e-266) {
tmp = (x + (b * ((b * (b * (x * ((0.5 / b) - 0.16666666666666666)))) - x))) / y;
} else {
tmp = x / (y * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.1e-187: tmp = (x * ((1.0 / y) - (b * ((1.0 / y) + (b * ((0.5 * (-1.0 / y)) - (-0.16666666666666666 * (b / y)))))))) / a elif b <= -1.55e-266: tmp = (x + (b * ((b * (b * (x * ((0.5 / b) - 0.16666666666666666)))) - x))) / y else: tmp = x / (y * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.1e-187) tmp = Float64(Float64(x * Float64(Float64(1.0 / y) - Float64(b * Float64(Float64(1.0 / y) + Float64(b * Float64(Float64(0.5 * Float64(-1.0 / y)) - Float64(-0.16666666666666666 * Float64(b / y)))))))) / a); elseif (b <= -1.55e-266) tmp = Float64(Float64(x + Float64(b * Float64(Float64(b * Float64(b * Float64(x * Float64(Float64(0.5 / b) - 0.16666666666666666)))) - x))) / 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 (b <= -1.1e-187) tmp = (x * ((1.0 / y) - (b * ((1.0 / y) + (b * ((0.5 * (-1.0 / y)) - (-0.16666666666666666 * (b / y)))))))) / a; elseif (b <= -1.55e-266) tmp = (x + (b * ((b * (b * (x * ((0.5 / b) - 0.16666666666666666)))) - x))) / y; else tmp = x / (y * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.1e-187], N[(N[(x * N[(N[(1.0 / y), $MachinePrecision] - N[(b * N[(N[(1.0 / y), $MachinePrecision] + N[(b * N[(N[(0.5 * N[(-1.0 / y), $MachinePrecision]), $MachinePrecision] - N[(-0.16666666666666666 * N[(b / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b, -1.55e-266], N[(N[(x + N[(b * N[(N[(b * N[(b * N[(x * N[(N[(0.5 / b), $MachinePrecision] - 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.1 \cdot 10^{-187}:\\
\;\;\;\;\frac{x \cdot \left(\frac{1}{y} - b \cdot \left(\frac{1}{y} + b \cdot \left(0.5 \cdot \frac{-1}{y} - -0.16666666666666666 \cdot \frac{b}{y}\right)\right)\right)}{a}\\
\mathbf{elif}\;b \leq -1.55 \cdot 10^{-266}:\\
\;\;\;\;\frac{x + b \cdot \left(b \cdot \left(b \cdot \left(x \cdot \left(\frac{0.5}{b} - 0.16666666666666666\right)\right)\right) - x\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\end{array}
\end{array}
if b < -1.10000000000000004e-187Initial program 98.6%
associate-/l*99.4%
associate--l+99.4%
exp-sum80.5%
associate-/l*80.5%
*-commutative80.5%
exp-to-pow80.5%
exp-diff70.6%
*-commutative70.6%
exp-to-pow71.1%
sub-neg71.1%
metadata-eval71.1%
Simplified71.1%
Taylor expanded in y around 0 71.9%
associate-/r*68.2%
exp-to-pow68.8%
sub-neg68.8%
metadata-eval68.8%
Simplified68.8%
unpow-prod-up68.8%
unpow-168.8%
Applied egg-rr68.8%
associate-*r/68.8%
*-rgt-identity68.8%
Simplified68.8%
Taylor expanded in x around 0 71.4%
times-frac66.1%
Simplified66.1%
associate-*l/73.3%
Applied egg-rr73.3%
Taylor expanded in t around 0 71.9%
*-commutative71.9%
associate-/r*71.9%
rec-exp71.9%
Simplified71.9%
Taylor expanded in b around 0 63.4%
if -1.10000000000000004e-187 < b < -1.54999999999999998e-266Initial program 99.1%
*-commutative99.1%
associate-/l*99.1%
associate--l+99.1%
fma-define99.1%
sub-neg99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in b around inf 8.9%
neg-mul-18.9%
Simplified8.9%
Taylor expanded in b around 0 8.9%
Taylor expanded in y around 0 8.9%
Taylor expanded in b around inf 44.3%
Taylor expanded in x around -inf 44.3%
associate-*r*44.3%
neg-mul-144.3%
associate-*r/44.3%
metadata-eval44.3%
Simplified44.3%
if -1.54999999999999998e-266 < b Initial program 98.9%
associate-/l*96.3%
associate--l+96.3%
exp-sum79.6%
associate-/l*78.8%
*-commutative78.8%
exp-to-pow78.8%
exp-diff71.7%
*-commutative71.7%
exp-to-pow72.3%
sub-neg72.3%
metadata-eval72.3%
Simplified72.3%
Taylor expanded in t around 0 70.1%
Taylor expanded in b around 0 54.8%
*-commutative54.8%
times-frac53.4%
Simplified53.4%
Taylor expanded in y around 0 36.7%
Final simplification48.9%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -7e+109)
(/ (* x (+ 1.0 (* b (+ (* b (+ 0.5 (* b -0.16666666666666666))) -1.0)))) y)
(if (<= b -3.9e-38)
(* (/ x a) (/ 1.0 y))
(if (<= b -2.5e-162) (* (/ x y) (/ 1.0 a)) (/ x (* y a))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -7e+109) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -3.9e-38) {
tmp = (x / a) * (1.0 / y);
} else if (b <= -2.5e-162) {
tmp = (x / y) * (1.0 / a);
} 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 (b <= (-7d+109)) then
tmp = (x * (1.0d0 + (b * ((b * (0.5d0 + (b * (-0.16666666666666666d0)))) + (-1.0d0))))) / y
else if (b <= (-3.9d-38)) then
tmp = (x / a) * (1.0d0 / y)
else if (b <= (-2.5d-162)) then
tmp = (x / y) * (1.0d0 / a)
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 (b <= -7e+109) {
tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y;
} else if (b <= -3.9e-38) {
tmp = (x / a) * (1.0 / y);
} else if (b <= -2.5e-162) {
tmp = (x / y) * (1.0 / a);
} else {
tmp = x / (y * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -7e+109: tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y elif b <= -3.9e-38: tmp = (x / a) * (1.0 / y) elif b <= -2.5e-162: tmp = (x / y) * (1.0 / a) else: tmp = x / (y * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -7e+109) tmp = Float64(Float64(x * Float64(1.0 + Float64(b * Float64(Float64(b * Float64(0.5 + Float64(b * -0.16666666666666666))) + -1.0)))) / y); elseif (b <= -3.9e-38) tmp = Float64(Float64(x / a) * Float64(1.0 / y)); elseif (b <= -2.5e-162) tmp = Float64(Float64(x / y) * Float64(1.0 / a)); 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 (b <= -7e+109) tmp = (x * (1.0 + (b * ((b * (0.5 + (b * -0.16666666666666666))) + -1.0)))) / y; elseif (b <= -3.9e-38) tmp = (x / a) * (1.0 / y); elseif (b <= -2.5e-162) tmp = (x / y) * (1.0 / a); else tmp = x / (y * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -7e+109], N[(N[(x * N[(1.0 + N[(b * N[(N[(b * N[(0.5 + N[(b * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -3.9e-38], N[(N[(x / a), $MachinePrecision] * N[(1.0 / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -2.5e-162], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -7 \cdot 10^{+109}:\\
\;\;\;\;\frac{x \cdot \left(1 + b \cdot \left(b \cdot \left(0.5 + b \cdot -0.16666666666666666\right) + -1\right)\right)}{y}\\
\mathbf{elif}\;b \leq -3.9 \cdot 10^{-38}:\\
\;\;\;\;\frac{x}{a} \cdot \frac{1}{y}\\
\mathbf{elif}\;b \leq -2.5 \cdot 10^{-162}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\end{array}
\end{array}
if b < -6.99999999999999966e109Initial program 100.0%
*-commutative100.0%
associate-/l*87.5%
associate--l+87.5%
fma-define87.5%
sub-neg87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in b around inf 81.3%
neg-mul-181.3%
Simplified81.3%
Taylor expanded in b around 0 74.4%
Taylor expanded in y around 0 83.9%
Taylor expanded in x around 0 87.9%
Taylor expanded in x around 0 93.8%
if -6.99999999999999966e109 < b < -3.8999999999999999e-38Initial program 99.0%
associate-/l*99.0%
associate--l+99.0%
exp-sum79.6%
associate-/l*79.6%
*-commutative79.6%
exp-to-pow79.6%
exp-diff62.9%
*-commutative62.9%
exp-to-pow63.7%
sub-neg63.7%
metadata-eval63.7%
Simplified63.7%
Taylor expanded in t around 0 59.0%
Taylor expanded in b around 0 70.3%
*-commutative70.3%
times-frac70.3%
Simplified70.3%
associate-*l/78.3%
Applied egg-rr78.3%
Taylor expanded in y around 0 38.2%
div-inv38.3%
Applied egg-rr38.3%
if -3.8999999999999999e-38 < b < -2.50000000000000007e-162Initial program 99.2%
associate-/l*99.2%
associate--l+99.2%
exp-sum81.9%
associate-/l*81.9%
*-commutative81.9%
exp-to-pow81.9%
exp-diff81.9%
*-commutative81.9%
exp-to-pow82.5%
sub-neg82.5%
metadata-eval82.5%
Simplified82.5%
Taylor expanded in t around 0 70.6%
Taylor expanded in b around 0 70.6%
*-commutative70.6%
times-frac65.7%
Simplified65.7%
Taylor expanded in y around 0 49.1%
if -2.50000000000000007e-162 < b Initial program 98.3%
associate-/l*96.1%
associate--l+96.1%
exp-sum80.6%
associate-/l*79.3%
*-commutative79.3%
exp-to-pow79.3%
exp-diff73.3%
*-commutative73.3%
exp-to-pow74.0%
sub-neg74.0%
metadata-eval74.0%
Simplified74.0%
Taylor expanded in t around 0 67.5%
Taylor expanded in b around 0 54.6%
*-commutative54.6%
times-frac56.8%
Simplified56.8%
Taylor expanded in y around 0 34.2%
Final simplification47.3%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -1.72e+165)
(/ (- x (* x b)) y)
(if (<= b -6e-59)
(/ (/ x a) y)
(if (<= b -1.9e-167) (* (/ x y) (/ 1.0 a)) (/ x (* y a))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.72e+165) {
tmp = (x - (x * b)) / y;
} else if (b <= -6e-59) {
tmp = (x / a) / y;
} else if (b <= -1.9e-167) {
tmp = (x / y) * (1.0 / a);
} 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 (b <= (-1.72d+165)) then
tmp = (x - (x * b)) / y
else if (b <= (-6d-59)) then
tmp = (x / a) / y
else if (b <= (-1.9d-167)) then
tmp = (x / y) * (1.0d0 / a)
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 (b <= -1.72e+165) {
tmp = (x - (x * b)) / y;
} else if (b <= -6e-59) {
tmp = (x / a) / y;
} else if (b <= -1.9e-167) {
tmp = (x / y) * (1.0 / a);
} else {
tmp = x / (y * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.72e+165: tmp = (x - (x * b)) / y elif b <= -6e-59: tmp = (x / a) / y elif b <= -1.9e-167: tmp = (x / y) * (1.0 / a) else: tmp = x / (y * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.72e+165) tmp = Float64(Float64(x - Float64(x * b)) / y); elseif (b <= -6e-59) tmp = Float64(Float64(x / a) / y); elseif (b <= -1.9e-167) tmp = Float64(Float64(x / y) * Float64(1.0 / a)); 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 (b <= -1.72e+165) tmp = (x - (x * b)) / y; elseif (b <= -6e-59) tmp = (x / a) / y; elseif (b <= -1.9e-167) tmp = (x / y) * (1.0 / a); else tmp = x / (y * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.72e+165], N[(N[(x - N[(x * b), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -6e-59], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.9e-167], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.72 \cdot 10^{+165}:\\
\;\;\;\;\frac{x - x \cdot b}{y}\\
\mathbf{elif}\;b \leq -6 \cdot 10^{-59}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{elif}\;b \leq -1.9 \cdot 10^{-167}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\end{array}
\end{array}
if b < -1.72e165Initial program 100.0%
*-commutative100.0%
associate-/l*88.2%
associate--l+88.2%
fma-define88.2%
sub-neg88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in b around inf 82.4%
neg-mul-182.4%
Simplified82.4%
Taylor expanded in b around 0 85.9%
Taylor expanded in y around 0 88.6%
Taylor expanded in b around 0 60.4%
mul-1-neg60.4%
distribute-rgt-neg-out60.4%
Simplified60.4%
if -1.72e165 < b < -6.0000000000000002e-59Initial program 99.2%
associate-/l*99.2%
associate--l+99.2%
exp-sum80.3%
associate-/l*80.3%
*-commutative80.3%
exp-to-pow80.3%
exp-diff69.0%
*-commutative69.0%
exp-to-pow69.7%
sub-neg69.7%
metadata-eval69.7%
Simplified69.7%
Taylor expanded in t around 0 66.5%
Taylor expanded in b around 0 70.5%
*-commutative70.5%
times-frac68.5%
Simplified68.5%
associate-*l/79.7%
Applied egg-rr79.7%
Taylor expanded in y around 0 39.5%
if -6.0000000000000002e-59 < b < -1.89999999999999984e-167Initial program 99.1%
associate-/l*99.1%
associate--l+99.1%
exp-sum84.8%
associate-/l*84.8%
*-commutative84.8%
exp-to-pow84.8%
exp-diff84.8%
*-commutative84.8%
exp-to-pow85.6%
sub-neg85.6%
metadata-eval85.6%
Simplified85.6%
Taylor expanded in t around 0 72.4%
Taylor expanded in b around 0 72.4%
*-commutative72.4%
times-frac72.0%
Simplified72.0%
Taylor expanded in y around 0 53.7%
if -1.89999999999999984e-167 < b Initial program 98.3%
associate-/l*96.1%
associate--l+96.1%
exp-sum80.6%
associate-/l*79.2%
*-commutative79.2%
exp-to-pow79.2%
exp-diff73.2%
*-commutative73.2%
exp-to-pow73.8%
sub-neg73.8%
metadata-eval73.8%
Simplified73.8%
Taylor expanded in t around 0 67.3%
Taylor expanded in b around 0 54.3%
*-commutative54.3%
times-frac56.5%
Simplified56.5%
Taylor expanded in y around 0 33.7%
Final simplification40.1%
(FPCore (x y z t a b) :precision binary64 (if (<= t -9.2e-23) (* x (/ 1.0 (* y a))) (* (/ x y) (/ 1.0 a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -9.2e-23) {
tmp = x * (1.0 / (y * a));
} 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 (t <= (-9.2d-23)) then
tmp = x * (1.0d0 / (y * a))
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 (t <= -9.2e-23) {
tmp = x * (1.0 / (y * a));
} else {
tmp = (x / y) * (1.0 / a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -9.2e-23: tmp = x * (1.0 / (y * a)) else: tmp = (x / y) * (1.0 / a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -9.2e-23) tmp = Float64(x * Float64(1.0 / Float64(y * a))); 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 (t <= -9.2e-23) tmp = x * (1.0 / (y * a)); else tmp = (x / y) * (1.0 / a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -9.2e-23], N[(x * N[(1.0 / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -9.2 \cdot 10^{-23}:\\
\;\;\;\;x \cdot \frac{1}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{a}\\
\end{array}
\end{array}
if t < -9.2000000000000004e-23Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum81.9%
associate-/l*81.9%
*-commutative81.9%
exp-to-pow81.9%
exp-diff70.8%
*-commutative70.8%
exp-to-pow70.8%
sub-neg70.8%
metadata-eval70.8%
Simplified70.8%
Taylor expanded in t around 0 59.3%
Taylor expanded in b around 0 58.2%
*-commutative58.2%
times-frac51.6%
Simplified51.6%
Taylor expanded in y around 0 37.1%
div-inv38.4%
*-commutative38.4%
Applied egg-rr38.4%
if -9.2000000000000004e-23 < t Initial program 98.3%
associate-/l*96.5%
associate--l+96.5%
exp-sum79.7%
associate-/l*78.6%
*-commutative78.6%
exp-to-pow78.6%
exp-diff72.1%
*-commutative72.1%
exp-to-pow72.9%
sub-neg72.9%
metadata-eval72.9%
Simplified72.9%
Taylor expanded in t around 0 72.5%
Taylor expanded in b around 0 56.4%
*-commutative56.4%
times-frac60.1%
Simplified60.1%
Taylor expanded in y around 0 33.3%
(FPCore (x y z t a b) :precision binary64 (if (<= t -2.2e-24) (* x (/ 1.0 (* y a))) (/ (/ x y) a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -2.2e-24) {
tmp = x * (1.0 / (y * a));
} 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 (t <= (-2.2d-24)) then
tmp = x * (1.0d0 / (y * a))
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 (t <= -2.2e-24) {
tmp = x * (1.0 / (y * a));
} else {
tmp = (x / y) / a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -2.2e-24: tmp = x * (1.0 / (y * a)) else: tmp = (x / y) / a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -2.2e-24) tmp = Float64(x * Float64(1.0 / Float64(y * a))); else tmp = Float64(Float64(x / y) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -2.2e-24) tmp = x * (1.0 / (y * a)); else tmp = (x / y) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.2e-24], N[(x * N[(1.0 / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.2 \cdot 10^{-24}:\\
\;\;\;\;x \cdot \frac{1}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\end{array}
\end{array}
if t < -2.20000000000000002e-24Initial program 100.0%
associate-/l*100.0%
associate--l+100.0%
exp-sum81.9%
associate-/l*81.9%
*-commutative81.9%
exp-to-pow81.9%
exp-diff70.8%
*-commutative70.8%
exp-to-pow70.8%
sub-neg70.8%
metadata-eval70.8%
Simplified70.8%
Taylor expanded in t around 0 59.3%
Taylor expanded in b around 0 58.2%
*-commutative58.2%
times-frac51.6%
Simplified51.6%
Taylor expanded in y around 0 37.1%
div-inv38.4%
*-commutative38.4%
Applied egg-rr38.4%
if -2.20000000000000002e-24 < t Initial program 98.3%
associate-/l*96.5%
associate--l+96.5%
exp-sum79.7%
associate-/l*78.6%
*-commutative78.6%
exp-to-pow78.6%
exp-diff72.1%
*-commutative72.1%
exp-to-pow72.9%
sub-neg72.9%
metadata-eval72.9%
Simplified72.9%
Taylor expanded in t around 0 72.5%
Taylor expanded in b around 0 56.4%
*-commutative56.4%
times-frac60.1%
Simplified60.1%
Taylor expanded in y around 0 33.3%
un-div-inv33.2%
Applied egg-rr33.2%
(FPCore (x y z t a b) :precision binary64 (if (<= t 1.9e-167) (/ (/ x a) y) (/ (/ x y) a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= 1.9e-167) {
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 (t <= 1.9d-167) 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 (t <= 1.9e-167) {
tmp = (x / a) / y;
} else {
tmp = (x / y) / a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= 1.9e-167: tmp = (x / a) / y else: tmp = (x / y) / a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= 1.9e-167) tmp = Float64(Float64(x / a) / y); else tmp = Float64(Float64(x / y) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= 1.9e-167) tmp = (x / a) / y; else tmp = (x / y) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, 1.9e-167], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.9 \cdot 10^{-167}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{a}\\
\end{array}
\end{array}
if t < 1.89999999999999984e-167Initial program 98.6%
associate-/l*97.2%
associate--l+97.2%
exp-sum83.4%
associate-/l*82.2%
*-commutative82.2%
exp-to-pow82.2%
exp-diff77.4%
*-commutative77.4%
exp-to-pow78.0%
sub-neg78.0%
metadata-eval78.0%
Simplified78.0%
Taylor expanded in t around 0 72.4%
Taylor expanded in b around 0 60.4%
*-commutative60.4%
times-frac60.0%
Simplified60.0%
associate-*l/67.5%
Applied egg-rr67.5%
Taylor expanded in y around 0 39.0%
if 1.89999999999999984e-167 < t Initial program 99.1%
associate-/l*98.1%
associate--l+98.1%
exp-sum74.5%
associate-/l*74.5%
*-commutative74.5%
exp-to-pow74.5%
exp-diff61.0%
*-commutative61.0%
exp-to-pow61.7%
sub-neg61.7%
metadata-eval61.7%
Simplified61.7%
Taylor expanded in t around 0 62.0%
Taylor expanded in b around 0 50.4%
*-commutative50.4%
times-frac53.5%
Simplified53.5%
Taylor expanded in y around 0 26.6%
un-div-inv26.6%
Applied egg-rr26.6%
(FPCore (x y z t a b) :precision binary64 (/ x (* y a)))
double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / (y * a)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
def code(x, y, z, t, a, b): return x / (y * a)
function code(x, y, z, t, a, b) return Float64(x / Float64(y * a)) end
function tmp = code(x, y, z, t, a, b) tmp = x / (y * a); end
code[x_, y_, z_, t_, a_, b_] := N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y \cdot a}
\end{array}
Initial program 98.8%
associate-/l*97.5%
associate--l+97.5%
exp-sum80.3%
associate-/l*79.5%
*-commutative79.5%
exp-to-pow79.5%
exp-diff71.7%
*-commutative71.7%
exp-to-pow72.3%
sub-neg72.3%
metadata-eval72.3%
Simplified72.3%
Taylor expanded in t around 0 68.8%
Taylor expanded in b around 0 56.9%
*-commutative56.9%
times-frac57.7%
Simplified57.7%
Taylor expanded in y around 0 33.0%
Final simplification33.0%
(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 98.8%
*-commutative98.8%
associate-/l*89.2%
associate--l+89.2%
fma-define89.2%
sub-neg89.2%
metadata-eval89.2%
Simplified89.2%
Taylor expanded in b around inf 45.2%
neg-mul-145.2%
Simplified45.2%
Taylor expanded in b around 0 16.5%
(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 2024107
(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))