
(FPCore (x y z)
:precision binary64
(+
(+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
(/
(+
(* (- (* (+ y 0.0007936500793651) z) 0.0027777777777778) z)
0.083333333333333)
x)))
double code(double x, double y, double z) {
return ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((((x - 0.5d0) * log(x)) - x) + 0.91893853320467d0) + ((((((y + 0.0007936500793651d0) * z) - 0.0027777777777778d0) * z) + 0.083333333333333d0) / x)
end function
public static double code(double x, double y, double z) {
return ((((x - 0.5) * Math.log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x);
}
def code(x, y, z): return ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x)
function code(x, y, z) return Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(Float64(Float64(Float64(Float64(Float64(y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x)) end
function tmp = code(x, y, z) tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x); end
code[x_, y_, z_] := N[(N[(N[(N[(N[(x - 0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + 0.91893853320467), $MachinePrecision] + N[(N[(N[(N[(N[(N[(y + 0.0007936500793651), $MachinePrecision] * z), $MachinePrecision] - 0.0027777777777778), $MachinePrecision] * z), $MachinePrecision] + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 13 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z)
:precision binary64
(+
(+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
(/
(+
(* (- (* (+ y 0.0007936500793651) z) 0.0027777777777778) z)
0.083333333333333)
x)))
double code(double x, double y, double z) {
return ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((((x - 0.5d0) * log(x)) - x) + 0.91893853320467d0) + ((((((y + 0.0007936500793651d0) * z) - 0.0027777777777778d0) * z) + 0.083333333333333d0) / x)
end function
public static double code(double x, double y, double z) {
return ((((x - 0.5) * Math.log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x);
}
def code(x, y, z): return ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x)
function code(x, y, z) return Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(Float64(Float64(Float64(Float64(Float64(y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x)) end
function tmp = code(x, y, z) tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x); end
code[x_, y_, z_] := N[(N[(N[(N[(N[(x - 0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + 0.91893853320467), $MachinePrecision] + N[(N[(N[(N[(N[(N[(y + 0.0007936500793651), $MachinePrecision] * z), $MachinePrecision] - 0.0027777777777778), $MachinePrecision] * z), $MachinePrecision] + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x}
\end{array}
(FPCore (x y z)
:precision binary64
(if (<= x 90000000000.0)
(+
(+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
(/
(+
(* z (- (* z (+ y 0.0007936500793651)) 0.0027777777777778))
0.083333333333333)
x))
(+ (* x (+ (log x) -1.0)) (* z (* z (/ (+ y 0.0007936500793651) x))))))
double code(double x, double y, double z) {
double tmp;
if (x <= 90000000000.0) {
tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x);
} else {
tmp = (x * (log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= 90000000000.0d0) then
tmp = ((((x - 0.5d0) * log(x)) - x) + 0.91893853320467d0) + (((z * ((z * (y + 0.0007936500793651d0)) - 0.0027777777777778d0)) + 0.083333333333333d0) / x)
else
tmp = (x * (log(x) + (-1.0d0))) + (z * (z * ((y + 0.0007936500793651d0) / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= 90000000000.0) {
tmp = ((((x - 0.5) * Math.log(x)) - x) + 0.91893853320467) + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x);
} else {
tmp = (x * (Math.log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x)));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= 90000000000.0: tmp = ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x) else: tmp = (x * (math.log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x))) return tmp
function code(x, y, z) tmp = 0.0 if (x <= 90000000000.0) tmp = Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(Float64(Float64(z * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x)); else tmp = Float64(Float64(x * Float64(log(x) + -1.0)) + Float64(z * Float64(z * Float64(Float64(y + 0.0007936500793651) / x)))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= 90000000000.0) tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x); else tmp = (x * (log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, 90000000000.0], N[(N[(N[(N[(N[(x - 0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + 0.91893853320467), $MachinePrecision] + N[(N[(N[(z * N[(N[(z * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision] - 0.0027777777777778), $MachinePrecision]), $MachinePrecision] + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] + N[(z * N[(z * N[(N[(y + 0.0007936500793651), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 90000000000:\\
\;\;\;\;\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{z \cdot \left(z \cdot \left(y + 0.0007936500793651\right) - 0.0027777777777778\right) + 0.083333333333333}{x}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(\log x + -1\right) + z \cdot \left(z \cdot \frac{y + 0.0007936500793651}{x}\right)\\
\end{array}
\end{array}
if x < 9e10Initial program 99.7%
if 9e10 < x Initial program 87.0%
Taylor expanded in x around inf 87.1%
*-commutative87.1%
sub-neg87.1%
mul-1-neg87.1%
log-rec87.1%
remove-double-neg87.1%
metadata-eval87.1%
Simplified87.1%
Taylor expanded in z around inf 87.1%
associate-/l*91.2%
unpow291.2%
Simplified91.2%
Taylor expanded in z around 0 87.1%
associate-/l*91.2%
*-rgt-identity91.2%
associate-*r/91.2%
unpow291.2%
associate-*l*99.6%
associate-/r/99.7%
associate-*l/99.7%
*-lft-identity99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))))
(if (<= x 10000000000.0)
(+
(/
(+
(* z (- (* z (+ y 0.0007936500793651)) 0.0027777777777778))
0.083333333333333)
x)
t_0)
(+ t_0 (* z (* z (/ (+ y 0.0007936500793651) x)))))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double tmp;
if (x <= 10000000000.0) {
tmp = (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x) + t_0;
} else {
tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
if (x <= 10000000000.0d0) then
tmp = (((z * ((z * (y + 0.0007936500793651d0)) - 0.0027777777777778d0)) + 0.083333333333333d0) / x) + t_0
else
tmp = t_0 + (z * (z * ((y + 0.0007936500793651d0) / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double tmp;
if (x <= 10000000000.0) {
tmp = (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x) + t_0;
} else {
tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x)));
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) tmp = 0 if x <= 10000000000.0: tmp = (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x) + t_0 else: tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) tmp = 0.0 if (x <= 10000000000.0) tmp = Float64(Float64(Float64(Float64(z * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x) + t_0); else tmp = Float64(t_0 + Float64(z * Float64(z * Float64(Float64(y + 0.0007936500793651) / x)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); tmp = 0.0; if (x <= 10000000000.0) tmp = (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x) + t_0; else tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, 10000000000.0], N[(N[(N[(N[(z * N[(N[(z * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision] - 0.0027777777777778), $MachinePrecision]), $MachinePrecision] + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision] + t$95$0), $MachinePrecision], N[(t$95$0 + N[(z * N[(z * N[(N[(y + 0.0007936500793651), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
\mathbf{if}\;x \leq 10000000000:\\
\;\;\;\;\frac{z \cdot \left(z \cdot \left(y + 0.0007936500793651\right) - 0.0027777777777778\right) + 0.083333333333333}{x} + t_0\\
\mathbf{else}:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{y + 0.0007936500793651}{x}\right)\\
\end{array}
\end{array}
if x < 1e10Initial program 99.7%
Taylor expanded in x around inf 99.5%
*-commutative99.5%
sub-neg99.5%
mul-1-neg99.5%
log-rec99.5%
remove-double-neg99.5%
metadata-eval99.5%
Simplified99.5%
if 1e10 < x Initial program 87.0%
Taylor expanded in x around inf 87.1%
*-commutative87.1%
sub-neg87.1%
mul-1-neg87.1%
log-rec87.1%
remove-double-neg87.1%
metadata-eval87.1%
Simplified87.1%
Taylor expanded in z around inf 87.1%
associate-/l*91.2%
unpow291.2%
Simplified91.2%
Taylor expanded in z around 0 87.1%
associate-/l*91.2%
*-rgt-identity91.2%
associate-*r/91.2%
unpow291.2%
associate-*l*99.6%
associate-/r/99.7%
associate-*l/99.7%
*-lft-identity99.7%
Simplified99.7%
Final simplification99.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))) (t_1 (+ t_0 (* y (* z (/ z x))))))
(if (<= z -2e-94)
t_1
(if (<= z 205.0)
(+ t_0 (/ 0.083333333333333 x))
(if (<= z 5.3e+224)
(+ t_0 (* 0.0007936500793651 (/ z (/ x z))))
t_1)))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double t_1 = t_0 + (y * (z * (z / x)));
double tmp;
if (z <= -2e-94) {
tmp = t_1;
} else if (z <= 205.0) {
tmp = t_0 + (0.083333333333333 / x);
} else if (z <= 5.3e+224) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
t_1 = t_0 + (y * (z * (z / x)))
if (z <= (-2d-94)) then
tmp = t_1
else if (z <= 205.0d0) then
tmp = t_0 + (0.083333333333333d0 / x)
else if (z <= 5.3d+224) then
tmp = t_0 + (0.0007936500793651d0 * (z / (x / z)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double t_1 = t_0 + (y * (z * (z / x)));
double tmp;
if (z <= -2e-94) {
tmp = t_1;
} else if (z <= 205.0) {
tmp = t_0 + (0.083333333333333 / x);
} else if (z <= 5.3e+224) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) t_1 = t_0 + (y * (z * (z / x))) tmp = 0 if z <= -2e-94: tmp = t_1 elif z <= 205.0: tmp = t_0 + (0.083333333333333 / x) elif z <= 5.3e+224: tmp = t_0 + (0.0007936500793651 * (z / (x / z))) else: tmp = t_1 return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) t_1 = Float64(t_0 + Float64(y * Float64(z * Float64(z / x)))) tmp = 0.0 if (z <= -2e-94) tmp = t_1; elseif (z <= 205.0) tmp = Float64(t_0 + Float64(0.083333333333333 / x)); elseif (z <= 5.3e+224) tmp = Float64(t_0 + Float64(0.0007936500793651 * Float64(z / Float64(x / z)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); t_1 = t_0 + (y * (z * (z / x))); tmp = 0.0; if (z <= -2e-94) tmp = t_1; elseif (z <= 205.0) tmp = t_0 + (0.083333333333333 / x); elseif (z <= 5.3e+224) tmp = t_0 + (0.0007936500793651 * (z / (x / z))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(y * N[(z * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e-94], t$95$1, If[LessEqual[z, 205.0], N[(t$95$0 + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.3e+224], N[(t$95$0 + N[(0.0007936500793651 * N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
t_1 := t_0 + y \cdot \left(z \cdot \frac{z}{x}\right)\\
\mathbf{if}\;z \leq -2 \cdot 10^{-94}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 205:\\
\;\;\;\;t_0 + \frac{0.083333333333333}{x}\\
\mathbf{elif}\;z \leq 5.3 \cdot 10^{+224}:\\
\;\;\;\;t_0 + 0.0007936500793651 \cdot \frac{z}{\frac{x}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.9999999999999999e-94 or 5.2999999999999999e224 < z Initial program 91.7%
Taylor expanded in x around inf 91.8%
*-commutative91.8%
sub-neg91.8%
mul-1-neg91.8%
log-rec91.8%
remove-double-neg91.8%
metadata-eval91.8%
Simplified91.8%
Taylor expanded in z around inf 85.4%
associate-/l*85.9%
unpow285.9%
Simplified85.9%
Taylor expanded in y around inf 69.6%
associate-*r/73.1%
unpow273.1%
associate-/l*77.0%
Simplified77.0%
associate-/r/77.0%
Applied egg-rr77.0%
if -1.9999999999999999e-94 < z < 205Initial program 99.5%
Taylor expanded in x around inf 99.3%
*-commutative99.3%
sub-neg99.3%
mul-1-neg99.3%
log-rec99.3%
remove-double-neg99.3%
metadata-eval99.3%
Simplified99.3%
Taylor expanded in z around 0 94.5%
if 205 < z < 5.2999999999999999e224Initial program 89.6%
Taylor expanded in x around inf 89.6%
*-commutative89.6%
sub-neg89.6%
mul-1-neg89.6%
log-rec89.6%
remove-double-neg89.6%
metadata-eval89.6%
Simplified89.6%
Taylor expanded in z around inf 88.7%
associate-/l*92.1%
unpow292.1%
Simplified92.1%
Taylor expanded in y around 0 77.1%
unpow277.1%
associate-/l*80.3%
Simplified80.3%
Final simplification84.5%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))))
(if (<= z -2e-94)
(+ t_0 (/ y (/ (/ x z) z)))
(if (<= z 205.0)
(+ t_0 (/ 0.083333333333333 x))
(if (<= z 3.2e+226)
(+ t_0 (* 0.0007936500793651 (/ z (/ x z))))
(+ t_0 (* y (* z (/ z x)))))))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + (y / ((x / z) / z));
} else if (z <= 205.0) {
tmp = t_0 + (0.083333333333333 / x);
} else if (z <= 3.2e+226) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (y * (z * (z / x)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
if (z <= (-2d-94)) then
tmp = t_0 + (y / ((x / z) / z))
else if (z <= 205.0d0) then
tmp = t_0 + (0.083333333333333d0 / x)
else if (z <= 3.2d+226) then
tmp = t_0 + (0.0007936500793651d0 * (z / (x / z)))
else
tmp = t_0 + (y * (z * (z / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + (y / ((x / z) / z));
} else if (z <= 205.0) {
tmp = t_0 + (0.083333333333333 / x);
} else if (z <= 3.2e+226) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (y * (z * (z / x)));
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) tmp = 0 if z <= -2e-94: tmp = t_0 + (y / ((x / z) / z)) elif z <= 205.0: tmp = t_0 + (0.083333333333333 / x) elif z <= 3.2e+226: tmp = t_0 + (0.0007936500793651 * (z / (x / z))) else: tmp = t_0 + (y * (z * (z / x))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) tmp = 0.0 if (z <= -2e-94) tmp = Float64(t_0 + Float64(y / Float64(Float64(x / z) / z))); elseif (z <= 205.0) tmp = Float64(t_0 + Float64(0.083333333333333 / x)); elseif (z <= 3.2e+226) tmp = Float64(t_0 + Float64(0.0007936500793651 * Float64(z / Float64(x / z)))); else tmp = Float64(t_0 + Float64(y * Float64(z * Float64(z / x)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); tmp = 0.0; if (z <= -2e-94) tmp = t_0 + (y / ((x / z) / z)); elseif (z <= 205.0) tmp = t_0 + (0.083333333333333 / x); elseif (z <= 3.2e+226) tmp = t_0 + (0.0007936500793651 * (z / (x / z))); else tmp = t_0 + (y * (z * (z / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e-94], N[(t$95$0 + N[(y / N[(N[(x / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 205.0], N[(t$95$0 + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e+226], N[(t$95$0 + N[(0.0007936500793651 * N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(y * N[(z * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
\mathbf{if}\;z \leq -2 \cdot 10^{-94}:\\
\;\;\;\;t_0 + \frac{y}{\frac{\frac{x}{z}}{z}}\\
\mathbf{elif}\;z \leq 205:\\
\;\;\;\;t_0 + \frac{0.083333333333333}{x}\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+226}:\\
\;\;\;\;t_0 + 0.0007936500793651 \cdot \frac{z}{\frac{x}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + y \cdot \left(z \cdot \frac{z}{x}\right)\\
\end{array}
\end{array}
if z < -1.9999999999999999e-94Initial program 93.6%
Taylor expanded in x around inf 93.6%
*-commutative93.6%
sub-neg93.6%
mul-1-neg93.6%
log-rec93.6%
remove-double-neg93.6%
metadata-eval93.6%
Simplified93.6%
Taylor expanded in y around inf 69.0%
associate-/l*73.0%
unpow273.0%
associate-/r*76.3%
Simplified76.3%
if -1.9999999999999999e-94 < z < 205Initial program 99.5%
Taylor expanded in x around inf 99.3%
*-commutative99.3%
sub-neg99.3%
mul-1-neg99.3%
log-rec99.3%
remove-double-neg99.3%
metadata-eval99.3%
Simplified99.3%
Taylor expanded in z around 0 94.5%
if 205 < z < 3.19999999999999977e226Initial program 89.6%
Taylor expanded in x around inf 89.6%
*-commutative89.6%
sub-neg89.6%
mul-1-neg89.6%
log-rec89.6%
remove-double-neg89.6%
metadata-eval89.6%
Simplified89.6%
Taylor expanded in z around inf 88.7%
associate-/l*92.1%
unpow292.1%
Simplified92.1%
Taylor expanded in y around 0 77.1%
unpow277.1%
associate-/l*80.3%
Simplified80.3%
if 3.19999999999999977e226 < z Initial program 81.1%
Taylor expanded in x around inf 81.1%
*-commutative81.1%
sub-neg81.1%
mul-1-neg81.1%
log-rec81.1%
remove-double-neg81.1%
metadata-eval81.1%
Simplified81.1%
Taylor expanded in z around inf 81.1%
associate-/l*81.1%
unpow281.1%
Simplified81.1%
Taylor expanded in y around inf 73.3%
associate-*r/73.3%
unpow273.3%
associate-/l*81.1%
Simplified81.1%
associate-/r/81.1%
Applied egg-rr81.1%
Final simplification84.5%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))))
(if (<= z -2e-94)
(+ t_0 (/ y (/ (/ x z) z)))
(if (<= z 205.0)
(+ t_0 (/ (+ 0.083333333333333 (* z -0.0027777777777778)) x))
(if (<= z 4.8e+224)
(+ t_0 (* 0.0007936500793651 (/ z (/ x z))))
(+ t_0 (* y (* z (/ z x)))))))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + (y / ((x / z) / z));
} else if (z <= 205.0) {
tmp = t_0 + ((0.083333333333333 + (z * -0.0027777777777778)) / x);
} else if (z <= 4.8e+224) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (y * (z * (z / x)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
if (z <= (-2d-94)) then
tmp = t_0 + (y / ((x / z) / z))
else if (z <= 205.0d0) then
tmp = t_0 + ((0.083333333333333d0 + (z * (-0.0027777777777778d0))) / x)
else if (z <= 4.8d+224) then
tmp = t_0 + (0.0007936500793651d0 * (z / (x / z)))
else
tmp = t_0 + (y * (z * (z / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + (y / ((x / z) / z));
} else if (z <= 205.0) {
tmp = t_0 + ((0.083333333333333 + (z * -0.0027777777777778)) / x);
} else if (z <= 4.8e+224) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (y * (z * (z / x)));
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) tmp = 0 if z <= -2e-94: tmp = t_0 + (y / ((x / z) / z)) elif z <= 205.0: tmp = t_0 + ((0.083333333333333 + (z * -0.0027777777777778)) / x) elif z <= 4.8e+224: tmp = t_0 + (0.0007936500793651 * (z / (x / z))) else: tmp = t_0 + (y * (z * (z / x))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) tmp = 0.0 if (z <= -2e-94) tmp = Float64(t_0 + Float64(y / Float64(Float64(x / z) / z))); elseif (z <= 205.0) tmp = Float64(t_0 + Float64(Float64(0.083333333333333 + Float64(z * -0.0027777777777778)) / x)); elseif (z <= 4.8e+224) tmp = Float64(t_0 + Float64(0.0007936500793651 * Float64(z / Float64(x / z)))); else tmp = Float64(t_0 + Float64(y * Float64(z * Float64(z / x)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); tmp = 0.0; if (z <= -2e-94) tmp = t_0 + (y / ((x / z) / z)); elseif (z <= 205.0) tmp = t_0 + ((0.083333333333333 + (z * -0.0027777777777778)) / x); elseif (z <= 4.8e+224) tmp = t_0 + (0.0007936500793651 * (z / (x / z))); else tmp = t_0 + (y * (z * (z / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e-94], N[(t$95$0 + N[(y / N[(N[(x / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 205.0], N[(t$95$0 + N[(N[(0.083333333333333 + N[(z * -0.0027777777777778), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.8e+224], N[(t$95$0 + N[(0.0007936500793651 * N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(y * N[(z * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
\mathbf{if}\;z \leq -2 \cdot 10^{-94}:\\
\;\;\;\;t_0 + \frac{y}{\frac{\frac{x}{z}}{z}}\\
\mathbf{elif}\;z \leq 205:\\
\;\;\;\;t_0 + \frac{0.083333333333333 + z \cdot -0.0027777777777778}{x}\\
\mathbf{elif}\;z \leq 4.8 \cdot 10^{+224}:\\
\;\;\;\;t_0 + 0.0007936500793651 \cdot \frac{z}{\frac{x}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + y \cdot \left(z \cdot \frac{z}{x}\right)\\
\end{array}
\end{array}
if z < -1.9999999999999999e-94Initial program 93.6%
Taylor expanded in x around inf 93.6%
*-commutative93.6%
sub-neg93.6%
mul-1-neg93.6%
log-rec93.6%
remove-double-neg93.6%
metadata-eval93.6%
Simplified93.6%
Taylor expanded in y around inf 69.0%
associate-/l*73.0%
unpow273.0%
associate-/r*76.3%
Simplified76.3%
if -1.9999999999999999e-94 < z < 205Initial program 99.5%
Taylor expanded in x around inf 99.3%
*-commutative99.3%
sub-neg99.3%
mul-1-neg99.3%
log-rec99.3%
remove-double-neg99.3%
metadata-eval99.3%
Simplified99.3%
Taylor expanded in z around 0 94.5%
*-commutative94.5%
Simplified94.5%
if 205 < z < 4.80000000000000002e224Initial program 89.6%
Taylor expanded in x around inf 89.6%
*-commutative89.6%
sub-neg89.6%
mul-1-neg89.6%
log-rec89.6%
remove-double-neg89.6%
metadata-eval89.6%
Simplified89.6%
Taylor expanded in z around inf 88.7%
associate-/l*92.1%
unpow292.1%
Simplified92.1%
Taylor expanded in y around 0 77.1%
unpow277.1%
associate-/l*80.3%
Simplified80.3%
if 4.80000000000000002e224 < z Initial program 81.1%
Taylor expanded in x around inf 81.1%
*-commutative81.1%
sub-neg81.1%
mul-1-neg81.1%
log-rec81.1%
remove-double-neg81.1%
metadata-eval81.1%
Simplified81.1%
Taylor expanded in z around inf 81.1%
associate-/l*81.1%
unpow281.1%
Simplified81.1%
Taylor expanded in y around inf 73.3%
associate-*r/73.3%
unpow273.3%
associate-/l*81.1%
Simplified81.1%
associate-/r/81.1%
Applied egg-rr81.1%
Final simplification84.5%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))))
(if (<= z -2e-94)
(+ t_0 (/ y (/ (/ x z) z)))
(if (<= z 205.0)
(+
(+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
(/ 0.083333333333333 x))
(if (<= z 7.1e+224)
(+ t_0 (* 0.0007936500793651 (/ z (/ x z))))
(+ t_0 (* y (* z (/ z x)))))))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + (y / ((x / z) / z));
} else if (z <= 205.0) {
tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x);
} else if (z <= 7.1e+224) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (y * (z * (z / x)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
if (z <= (-2d-94)) then
tmp = t_0 + (y / ((x / z) / z))
else if (z <= 205.0d0) then
tmp = ((((x - 0.5d0) * log(x)) - x) + 0.91893853320467d0) + (0.083333333333333d0 / x)
else if (z <= 7.1d+224) then
tmp = t_0 + (0.0007936500793651d0 * (z / (x / z)))
else
tmp = t_0 + (y * (z * (z / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + (y / ((x / z) / z));
} else if (z <= 205.0) {
tmp = ((((x - 0.5) * Math.log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x);
} else if (z <= 7.1e+224) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (y * (z * (z / x)));
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) tmp = 0 if z <= -2e-94: tmp = t_0 + (y / ((x / z) / z)) elif z <= 205.0: tmp = ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x) elif z <= 7.1e+224: tmp = t_0 + (0.0007936500793651 * (z / (x / z))) else: tmp = t_0 + (y * (z * (z / x))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) tmp = 0.0 if (z <= -2e-94) tmp = Float64(t_0 + Float64(y / Float64(Float64(x / z) / z))); elseif (z <= 205.0) tmp = Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(0.083333333333333 / x)); elseif (z <= 7.1e+224) tmp = Float64(t_0 + Float64(0.0007936500793651 * Float64(z / Float64(x / z)))); else tmp = Float64(t_0 + Float64(y * Float64(z * Float64(z / x)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); tmp = 0.0; if (z <= -2e-94) tmp = t_0 + (y / ((x / z) / z)); elseif (z <= 205.0) tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x); elseif (z <= 7.1e+224) tmp = t_0 + (0.0007936500793651 * (z / (x / z))); else tmp = t_0 + (y * (z * (z / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e-94], N[(t$95$0 + N[(y / N[(N[(x / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 205.0], N[(N[(N[(N[(N[(x - 0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + 0.91893853320467), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.1e+224], N[(t$95$0 + N[(0.0007936500793651 * N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(y * N[(z * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
\mathbf{if}\;z \leq -2 \cdot 10^{-94}:\\
\;\;\;\;t_0 + \frac{y}{\frac{\frac{x}{z}}{z}}\\
\mathbf{elif}\;z \leq 205:\\
\;\;\;\;\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{0.083333333333333}{x}\\
\mathbf{elif}\;z \leq 7.1 \cdot 10^{+224}:\\
\;\;\;\;t_0 + 0.0007936500793651 \cdot \frac{z}{\frac{x}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + y \cdot \left(z \cdot \frac{z}{x}\right)\\
\end{array}
\end{array}
if z < -1.9999999999999999e-94Initial program 93.6%
Taylor expanded in x around inf 93.6%
*-commutative93.6%
sub-neg93.6%
mul-1-neg93.6%
log-rec93.6%
remove-double-neg93.6%
metadata-eval93.6%
Simplified93.6%
Taylor expanded in y around inf 69.0%
associate-/l*73.0%
unpow273.0%
associate-/r*76.3%
Simplified76.3%
if -1.9999999999999999e-94 < z < 205Initial program 99.5%
Taylor expanded in z around 0 94.7%
if 205 < z < 7.0999999999999998e224Initial program 89.6%
Taylor expanded in x around inf 89.6%
*-commutative89.6%
sub-neg89.6%
mul-1-neg89.6%
log-rec89.6%
remove-double-neg89.6%
metadata-eval89.6%
Simplified89.6%
Taylor expanded in z around inf 88.7%
associate-/l*92.1%
unpow292.1%
Simplified92.1%
Taylor expanded in y around 0 77.1%
unpow277.1%
associate-/l*80.3%
Simplified80.3%
if 7.0999999999999998e224 < z Initial program 81.1%
Taylor expanded in x around inf 81.1%
*-commutative81.1%
sub-neg81.1%
mul-1-neg81.1%
log-rec81.1%
remove-double-neg81.1%
metadata-eval81.1%
Simplified81.1%
Taylor expanded in z around inf 81.1%
associate-/l*81.1%
unpow281.1%
Simplified81.1%
Taylor expanded in y around inf 73.3%
associate-*r/73.3%
unpow273.3%
associate-/l*81.1%
Simplified81.1%
associate-/r/81.1%
Applied egg-rr81.1%
Final simplification84.5%
(FPCore (x y z)
:precision binary64
(if (or (<= z -2.6e-13) (not (<= z 9.2e-36)))
(+ (* x (+ (log x) -1.0)) (* z (* z (/ (+ y 0.0007936500793651) x))))
(+
(+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
(/ 0.083333333333333 x))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -2.6e-13) || !(z <= 9.2e-36)) {
tmp = (x * (log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x)));
} else {
tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z <= (-2.6d-13)) .or. (.not. (z <= 9.2d-36))) then
tmp = (x * (log(x) + (-1.0d0))) + (z * (z * ((y + 0.0007936500793651d0) / x)))
else
tmp = ((((x - 0.5d0) * log(x)) - x) + 0.91893853320467d0) + (0.083333333333333d0 / x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -2.6e-13) || !(z <= 9.2e-36)) {
tmp = (x * (Math.log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x)));
} else {
tmp = ((((x - 0.5) * Math.log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -2.6e-13) or not (z <= 9.2e-36): tmp = (x * (math.log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x))) else: tmp = ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -2.6e-13) || !(z <= 9.2e-36)) tmp = Float64(Float64(x * Float64(log(x) + -1.0)) + Float64(z * Float64(z * Float64(Float64(y + 0.0007936500793651) / x)))); else tmp = Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(0.083333333333333 / x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -2.6e-13) || ~((z <= 9.2e-36))) tmp = (x * (log(x) + -1.0)) + (z * (z * ((y + 0.0007936500793651) / x))); else tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -2.6e-13], N[Not[LessEqual[z, 9.2e-36]], $MachinePrecision]], N[(N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] + N[(z * N[(z * N[(N[(y + 0.0007936500793651), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(x - 0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + 0.91893853320467), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.6 \cdot 10^{-13} \lor \neg \left(z \leq 9.2 \cdot 10^{-36}\right):\\
\;\;\;\;x \cdot \left(\log x + -1\right) + z \cdot \left(z \cdot \frac{y + 0.0007936500793651}{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{0.083333333333333}{x}\\
\end{array}
\end{array}
if z < -2.6e-13 or 9.19999999999999986e-36 < z Initial program 90.0%
Taylor expanded in x around inf 90.1%
*-commutative90.1%
sub-neg90.1%
mul-1-neg90.1%
log-rec90.1%
remove-double-neg90.1%
metadata-eval90.1%
Simplified90.1%
Taylor expanded in z around inf 89.2%
associate-/l*92.4%
unpow292.4%
Simplified92.4%
Taylor expanded in z around 0 89.2%
associate-/l*92.4%
*-rgt-identity92.4%
associate-*r/92.3%
unpow292.3%
associate-*l*98.9%
associate-/r/98.9%
associate-*l/99.0%
*-lft-identity99.0%
Simplified99.0%
if -2.6e-13 < z < 9.19999999999999986e-36Initial program 99.5%
Taylor expanded in z around 0 90.6%
Final simplification95.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))))
(if (<= z -2e-94)
(+ t_0 (* (+ y 0.0007936500793651) (/ z (/ x z))))
(if (<= z 3e-32)
(+
(+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
(/ 0.083333333333333 x))
(+ t_0 (* z (* z (/ (+ y 0.0007936500793651) x))))))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z)));
} else if (z <= 3e-32) {
tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x);
} else {
tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
if (z <= (-2d-94)) then
tmp = t_0 + ((y + 0.0007936500793651d0) * (z / (x / z)))
else if (z <= 3d-32) then
tmp = ((((x - 0.5d0) * log(x)) - x) + 0.91893853320467d0) + (0.083333333333333d0 / x)
else
tmp = t_0 + (z * (z * ((y + 0.0007936500793651d0) / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double tmp;
if (z <= -2e-94) {
tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z)));
} else if (z <= 3e-32) {
tmp = ((((x - 0.5) * Math.log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x);
} else {
tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x)));
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) tmp = 0 if z <= -2e-94: tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z))) elif z <= 3e-32: tmp = ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x) else: tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) tmp = 0.0 if (z <= -2e-94) tmp = Float64(t_0 + Float64(Float64(y + 0.0007936500793651) * Float64(z / Float64(x / z)))); elseif (z <= 3e-32) tmp = Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(0.083333333333333 / x)); else tmp = Float64(t_0 + Float64(z * Float64(z * Float64(Float64(y + 0.0007936500793651) / x)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); tmp = 0.0; if (z <= -2e-94) tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z))); elseif (z <= 3e-32) tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + (0.083333333333333 / x); else tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e-94], N[(t$95$0 + N[(N[(y + 0.0007936500793651), $MachinePrecision] * N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3e-32], N[(N[(N[(N[(N[(x - 0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + 0.91893853320467), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(z * N[(z * N[(N[(y + 0.0007936500793651), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
\mathbf{if}\;z \leq -2 \cdot 10^{-94}:\\
\;\;\;\;t_0 + \left(y + 0.0007936500793651\right) \cdot \frac{z}{\frac{x}{z}}\\
\mathbf{elif}\;z \leq 3 \cdot 10^{-32}:\\
\;\;\;\;\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{0.083333333333333}{x}\\
\mathbf{else}:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{y + 0.0007936500793651}{x}\right)\\
\end{array}
\end{array}
if z < -1.9999999999999999e-94Initial program 93.6%
Taylor expanded in x around inf 93.6%
*-commutative93.6%
sub-neg93.6%
mul-1-neg93.6%
log-rec93.6%
remove-double-neg93.6%
metadata-eval93.6%
Simplified93.6%
Taylor expanded in z around inf 86.1%
associate-/l*86.8%
unpow286.8%
Simplified86.8%
Taylor expanded in z around 0 86.1%
associate-*l/89.3%
unpow289.3%
*-commutative89.3%
associate-/l*92.3%
Simplified92.3%
if -1.9999999999999999e-94 < z < 3e-32Initial program 99.5%
Taylor expanded in z around 0 96.5%
if 3e-32 < z Initial program 88.4%
Taylor expanded in x around inf 88.5%
*-commutative88.5%
sub-neg88.5%
mul-1-neg88.5%
log-rec88.5%
remove-double-neg88.5%
metadata-eval88.5%
Simplified88.5%
Taylor expanded in z around inf 87.7%
associate-/l*90.3%
unpow290.3%
Simplified90.3%
Taylor expanded in z around 0 87.7%
associate-/l*90.3%
*-rgt-identity90.3%
associate-*r/90.3%
unpow290.3%
associate-*l*99.0%
associate-/r/99.0%
associate-*l/99.0%
*-lft-identity99.0%
Simplified99.0%
Final simplification95.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))))
(if (<= z -19000.0)
(+ t_0 (* z (* z (/ (+ y 0.0007936500793651) x))))
(if (<= z 1.2e-13)
(+ t_0 (/ (+ 0.083333333333333 (* z (* y z))) x))
(+ t_0 (* (+ y 0.0007936500793651) (/ z (/ x z))))))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double tmp;
if (z <= -19000.0) {
tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x)));
} else if (z <= 1.2e-13) {
tmp = t_0 + ((0.083333333333333 + (z * (y * z))) / x);
} else {
tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z)));
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
if (z <= (-19000.0d0)) then
tmp = t_0 + (z * (z * ((y + 0.0007936500793651d0) / x)))
else if (z <= 1.2d-13) then
tmp = t_0 + ((0.083333333333333d0 + (z * (y * z))) / x)
else
tmp = t_0 + ((y + 0.0007936500793651d0) * (z / (x / z)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double tmp;
if (z <= -19000.0) {
tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x)));
} else if (z <= 1.2e-13) {
tmp = t_0 + ((0.083333333333333 + (z * (y * z))) / x);
} else {
tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z)));
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) tmp = 0 if z <= -19000.0: tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x))) elif z <= 1.2e-13: tmp = t_0 + ((0.083333333333333 + (z * (y * z))) / x) else: tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z))) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) tmp = 0.0 if (z <= -19000.0) tmp = Float64(t_0 + Float64(z * Float64(z * Float64(Float64(y + 0.0007936500793651) / x)))); elseif (z <= 1.2e-13) tmp = Float64(t_0 + Float64(Float64(0.083333333333333 + Float64(z * Float64(y * z))) / x)); else tmp = Float64(t_0 + Float64(Float64(y + 0.0007936500793651) * Float64(z / Float64(x / z)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); tmp = 0.0; if (z <= -19000.0) tmp = t_0 + (z * (z * ((y + 0.0007936500793651) / x))); elseif (z <= 1.2e-13) tmp = t_0 + ((0.083333333333333 + (z * (y * z))) / x); else tmp = t_0 + ((y + 0.0007936500793651) * (z / (x / z))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -19000.0], N[(t$95$0 + N[(z * N[(z * N[(N[(y + 0.0007936500793651), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.2e-13], N[(t$95$0 + N[(N[(0.083333333333333 + N[(z * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(N[(y + 0.0007936500793651), $MachinePrecision] * N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
\mathbf{if}\;z \leq -19000:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{y + 0.0007936500793651}{x}\right)\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{-13}:\\
\;\;\;\;t_0 + \frac{0.083333333333333 + z \cdot \left(y \cdot z\right)}{x}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \left(y + 0.0007936500793651\right) \cdot \frac{z}{\frac{x}{z}}\\
\end{array}
\end{array}
if z < -19000Initial program 91.4%
Taylor expanded in x around inf 91.4%
*-commutative91.4%
sub-neg91.4%
mul-1-neg91.4%
log-rec91.4%
remove-double-neg91.4%
metadata-eval91.4%
Simplified91.4%
Taylor expanded in z around inf 90.4%
associate-/l*94.4%
unpow294.4%
Simplified94.4%
Taylor expanded in z around 0 90.4%
associate-/l*94.4%
*-rgt-identity94.4%
associate-*r/94.4%
unpow294.4%
associate-*l*98.9%
associate-/r/98.9%
associate-*l/98.9%
*-lft-identity98.9%
Simplified98.9%
if -19000 < z < 1.1999999999999999e-13Initial program 99.5%
Taylor expanded in x around inf 99.3%
*-commutative99.3%
sub-neg99.3%
mul-1-neg99.3%
log-rec99.3%
remove-double-neg99.3%
metadata-eval99.3%
Simplified99.3%
Taylor expanded in y around inf 99.3%
*-commutative99.3%
unpow299.3%
associate-*l*99.3%
Simplified99.3%
if 1.1999999999999999e-13 < z Initial program 88.3%
Taylor expanded in x around inf 88.3%
*-commutative88.3%
sub-neg88.3%
mul-1-neg88.3%
log-rec88.3%
remove-double-neg88.3%
metadata-eval88.3%
Simplified88.3%
Taylor expanded in z around inf 87.6%
associate-/l*90.2%
unpow290.2%
Simplified90.2%
Taylor expanded in z around 0 87.6%
associate-*l/90.1%
unpow290.1%
*-commutative90.1%
associate-/l*99.0%
Simplified99.0%
Final simplification99.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* x (+ (log x) -1.0))))
(if (or (<= z -6.2e-12) (not (<= z 205.0)))
(+ t_0 (* 0.0007936500793651 (/ z (/ x z))))
(+ t_0 (/ 0.083333333333333 x)))))
double code(double x, double y, double z) {
double t_0 = x * (log(x) + -1.0);
double tmp;
if ((z <= -6.2e-12) || !(z <= 205.0)) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (0.083333333333333 / x);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x * (log(x) + (-1.0d0))
if ((z <= (-6.2d-12)) .or. (.not. (z <= 205.0d0))) then
tmp = t_0 + (0.0007936500793651d0 * (z / (x / z)))
else
tmp = t_0 + (0.083333333333333d0 / x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x * (Math.log(x) + -1.0);
double tmp;
if ((z <= -6.2e-12) || !(z <= 205.0)) {
tmp = t_0 + (0.0007936500793651 * (z / (x / z)));
} else {
tmp = t_0 + (0.083333333333333 / x);
}
return tmp;
}
def code(x, y, z): t_0 = x * (math.log(x) + -1.0) tmp = 0 if (z <= -6.2e-12) or not (z <= 205.0): tmp = t_0 + (0.0007936500793651 * (z / (x / z))) else: tmp = t_0 + (0.083333333333333 / x) return tmp
function code(x, y, z) t_0 = Float64(x * Float64(log(x) + -1.0)) tmp = 0.0 if ((z <= -6.2e-12) || !(z <= 205.0)) tmp = Float64(t_0 + Float64(0.0007936500793651 * Float64(z / Float64(x / z)))); else tmp = Float64(t_0 + Float64(0.083333333333333 / x)); end return tmp end
function tmp_2 = code(x, y, z) t_0 = x * (log(x) + -1.0); tmp = 0.0; if ((z <= -6.2e-12) || ~((z <= 205.0))) tmp = t_0 + (0.0007936500793651 * (z / (x / z))); else tmp = t_0 + (0.083333333333333 / x); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[z, -6.2e-12], N[Not[LessEqual[z, 205.0]], $MachinePrecision]], N[(t$95$0 + N[(0.0007936500793651 * N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(\log x + -1\right)\\
\mathbf{if}\;z \leq -6.2 \cdot 10^{-12} \lor \neg \left(z \leq 205\right):\\
\;\;\;\;t_0 + 0.0007936500793651 \cdot \frac{z}{\frac{x}{z}}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{0.083333333333333}{x}\\
\end{array}
\end{array}
if z < -6.2000000000000002e-12 or 205 < z Initial program 89.7%
Taylor expanded in x around inf 89.8%
*-commutative89.8%
sub-neg89.8%
mul-1-neg89.8%
log-rec89.8%
remove-double-neg89.8%
metadata-eval89.8%
Simplified89.8%
Taylor expanded in z around inf 88.9%
associate-/l*92.1%
unpow292.1%
Simplified92.1%
Taylor expanded in y around 0 68.2%
unpow268.2%
associate-/l*70.4%
Simplified70.4%
if -6.2000000000000002e-12 < z < 205Initial program 99.5%
Taylor expanded in x around inf 99.3%
*-commutative99.3%
sub-neg99.3%
mul-1-neg99.3%
log-rec99.3%
remove-double-neg99.3%
metadata-eval99.3%
Simplified99.3%
Taylor expanded in z around 0 89.1%
Final simplification79.2%
(FPCore (x y z) :precision binary64 (+ (* x (+ (log x) -1.0)) (/ 0.083333333333333 x)))
double code(double x, double y, double z) {
return (x * (log(x) + -1.0)) + (0.083333333333333 / x);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (x * (log(x) + (-1.0d0))) + (0.083333333333333d0 / x)
end function
public static double code(double x, double y, double z) {
return (x * (Math.log(x) + -1.0)) + (0.083333333333333 / x);
}
def code(x, y, z): return (x * (math.log(x) + -1.0)) + (0.083333333333333 / x)
function code(x, y, z) return Float64(Float64(x * Float64(log(x) + -1.0)) + Float64(0.083333333333333 / x)) end
function tmp = code(x, y, z) tmp = (x * (log(x) + -1.0)) + (0.083333333333333 / x); end
code[x_, y_, z_] := N[(N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(\log x + -1\right) + \frac{0.083333333333333}{x}
\end{array}
Initial program 94.3%
Taylor expanded in x around inf 94.2%
*-commutative94.2%
sub-neg94.2%
mul-1-neg94.2%
log-rec94.2%
remove-double-neg94.2%
metadata-eval94.2%
Simplified94.2%
Taylor expanded in z around 0 55.9%
Final simplification55.9%
(FPCore (x y z) :precision binary64 (if (<= x 6.8e-13) (/ 0.083333333333333 x) (* x (+ (log x) -1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= 6.8e-13) {
tmp = 0.083333333333333 / x;
} else {
tmp = x * (log(x) + -1.0);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= 6.8d-13) then
tmp = 0.083333333333333d0 / x
else
tmp = x * (log(x) + (-1.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= 6.8e-13) {
tmp = 0.083333333333333 / x;
} else {
tmp = x * (Math.log(x) + -1.0);
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= 6.8e-13: tmp = 0.083333333333333 / x else: tmp = x * (math.log(x) + -1.0) return tmp
function code(x, y, z) tmp = 0.0 if (x <= 6.8e-13) tmp = Float64(0.083333333333333 / x); else tmp = Float64(x * Float64(log(x) + -1.0)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= 6.8e-13) tmp = 0.083333333333333 / x; else tmp = x * (log(x) + -1.0); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, 6.8e-13], N[(0.083333333333333 / x), $MachinePrecision], N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 6.8 \cdot 10^{-13}:\\
\;\;\;\;\frac{0.083333333333333}{x}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(\log x + -1\right)\\
\end{array}
\end{array}
if x < 6.80000000000000031e-13Initial program 99.7%
Taylor expanded in x around inf 99.5%
*-commutative99.5%
sub-neg99.5%
mul-1-neg99.5%
log-rec99.5%
remove-double-neg99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in z around 0 44.2%
Taylor expanded in x around 0 44.2%
if 6.80000000000000031e-13 < x Initial program 87.6%
Taylor expanded in x around inf 87.8%
*-commutative87.8%
sub-neg87.8%
mul-1-neg87.8%
log-rec87.8%
remove-double-neg87.8%
metadata-eval87.8%
Simplified87.8%
Taylor expanded in z around 0 70.1%
Taylor expanded in x around inf 70.2%
*-commutative70.2%
sub-neg70.2%
mul-1-neg70.2%
log-rec70.2%
remove-double-neg70.2%
metadata-eval70.2%
Simplified70.2%
Final simplification55.9%
(FPCore (x y z) :precision binary64 (/ 0.083333333333333 x))
double code(double x, double y, double z) {
return 0.083333333333333 / x;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 0.083333333333333d0 / x
end function
public static double code(double x, double y, double z) {
return 0.083333333333333 / x;
}
def code(x, y, z): return 0.083333333333333 / x
function code(x, y, z) return Float64(0.083333333333333 / x) end
function tmp = code(x, y, z) tmp = 0.083333333333333 / x; end
code[x_, y_, z_] := N[(0.083333333333333 / x), $MachinePrecision]
\begin{array}{l}
\\
\frac{0.083333333333333}{x}
\end{array}
Initial program 94.3%
Taylor expanded in x around inf 94.2%
*-commutative94.2%
sub-neg94.2%
mul-1-neg94.2%
log-rec94.2%
remove-double-neg94.2%
metadata-eval94.2%
Simplified94.2%
Taylor expanded in z around 0 55.9%
Taylor expanded in x around 0 25.6%
Final simplification25.6%
(FPCore (x y z) :precision binary64 (+ (+ (+ (* (- x 0.5) (log x)) (- 0.91893853320467 x)) (/ 0.083333333333333 x)) (* (/ z x) (- (* z (+ y 0.0007936500793651)) 0.0027777777777778))))
double code(double x, double y, double z) {
return ((((x - 0.5) * log(x)) + (0.91893853320467 - x)) + (0.083333333333333 / x)) + ((z / x) * ((z * (y + 0.0007936500793651)) - 0.0027777777777778));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((((x - 0.5d0) * log(x)) + (0.91893853320467d0 - x)) + (0.083333333333333d0 / x)) + ((z / x) * ((z * (y + 0.0007936500793651d0)) - 0.0027777777777778d0))
end function
public static double code(double x, double y, double z) {
return ((((x - 0.5) * Math.log(x)) + (0.91893853320467 - x)) + (0.083333333333333 / x)) + ((z / x) * ((z * (y + 0.0007936500793651)) - 0.0027777777777778));
}
def code(x, y, z): return ((((x - 0.5) * math.log(x)) + (0.91893853320467 - x)) + (0.083333333333333 / x)) + ((z / x) * ((z * (y + 0.0007936500793651)) - 0.0027777777777778))
function code(x, y, z) return Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) + Float64(0.91893853320467 - x)) + Float64(0.083333333333333 / x)) + Float64(Float64(z / x) * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778))) end
function tmp = code(x, y, z) tmp = ((((x - 0.5) * log(x)) + (0.91893853320467 - x)) + (0.083333333333333 / x)) + ((z / x) * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)); end
code[x_, y_, z_] := N[(N[(N[(N[(N[(x - 0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] + N[(0.91893853320467 - x), $MachinePrecision]), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision] + N[(N[(z / x), $MachinePrecision] * N[(N[(z * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision] - 0.0027777777777778), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(x - 0.5\right) \cdot \log x + \left(0.91893853320467 - x\right)\right) + \frac{0.083333333333333}{x}\right) + \frac{z}{x} \cdot \left(z \cdot \left(y + 0.0007936500793651\right) - 0.0027777777777778\right)
\end{array}
herbie shell --seed 2023196
(FPCore (x y z)
:name "Numeric.SpecFunctions:$slogFactorial from math-functions-0.1.5.2, B"
:precision binary64
:herbie-target
(+ (+ (+ (* (- x 0.5) (log x)) (- 0.91893853320467 x)) (/ 0.083333333333333 x)) (* (/ z x) (- (* z (+ y 0.0007936500793651)) 0.0027777777777778)))
(+ (+ (- (* (- x 0.5) (log x)) x) 0.91893853320467) (/ (+ (* (- (* (+ y 0.0007936500793651) z) 0.0027777777777778) z) 0.083333333333333) x)))