
(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 18 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 (<= (* z (- (* z (+ y 0.0007936500793651)) 0.0027777777777778)) 5e+143)
(+
(+ (fma (+ x -0.5) (log x) (- x)) 0.91893853320467)
(/
(fma
z
(fma (+ y 0.0007936500793651) z -0.0027777777777778)
0.083333333333333)
x))
(+ (- (* x (log x)) x) (* (/ z (/ x z)) (+ y 0.0007936500793651)))))
double code(double x, double y, double z) {
double tmp;
if ((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) <= 5e+143) {
tmp = (fma((x + -0.5), log(x), -x) + 0.91893853320467) + (fma(z, fma((y + 0.0007936500793651), z, -0.0027777777777778), 0.083333333333333) / x);
} else {
tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651));
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(z * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778)) <= 5e+143) tmp = Float64(Float64(fma(Float64(x + -0.5), log(x), Float64(-x)) + 0.91893853320467) + Float64(fma(z, fma(Float64(y + 0.0007936500793651), z, -0.0027777777777778), 0.083333333333333) / x)); else tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(Float64(z / Float64(x / z)) * Float64(y + 0.0007936500793651))); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(z * N[(N[(z * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision] - 0.0027777777777778), $MachinePrecision]), $MachinePrecision], 5e+143], N[(N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision] + (-x)), $MachinePrecision] + 0.91893853320467), $MachinePrecision] + N[(N[(z * N[(N[(y + 0.0007936500793651), $MachinePrecision] * z + -0.0027777777777778), $MachinePrecision] + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision] * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot \left(z \cdot \left(y + 0.0007936500793651\right) - 0.0027777777777778\right) \leq 5 \cdot 10^{+143}:\\
\;\;\;\;\left(\mathsf{fma}\left(x + -0.5, \log x, -x\right) + 0.91893853320467\right) + \frac{\mathsf{fma}\left(z, \mathsf{fma}\left(y + 0.0007936500793651, z, -0.0027777777777778\right), 0.083333333333333\right)}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot \log x - x\right) + \frac{z}{\frac{x}{z}} \cdot \left(y + 0.0007936500793651\right)\\
\end{array}
\end{array}
if (*.f64 (-.f64 (*.f64 (+.f64 y 7936500793651/10000000000000000) z) 13888888888889/5000000000000000) z) < 5.00000000000000012e143Initial program 99.5%
fma-neg99.6%
sub-neg99.6%
metadata-eval99.6%
*-commutative99.6%
fma-def99.6%
fma-neg99.6%
metadata-eval99.6%
Simplified99.6%
if 5.00000000000000012e143 < (*.f64 (-.f64 (*.f64 (+.f64 y 7936500793651/10000000000000000) z) 13888888888889/5000000000000000) z) Initial program 86.4%
sub-neg86.4%
metadata-eval86.4%
fma-def86.4%
fma-neg86.4%
metadata-eval86.4%
Simplified86.4%
Taylor expanded in x around inf 86.4%
sub-neg86.4%
mul-1-neg86.4%
log-rec86.4%
remove-double-neg86.4%
metadata-eval86.4%
distribute-rgt-in86.4%
*-rgt-identity86.4%
neg-mul-186.4%
*-rgt-identity86.4%
sub-neg86.4%
*-commutative86.4%
Simplified86.4%
Taylor expanded in x around 0 86.4%
Taylor expanded in z around inf 86.4%
associate-*l/90.1%
unpow290.1%
associate-/l*99.8%
Simplified99.8%
Final simplification99.7%
(FPCore (x y z)
:precision binary64
(if (<= (* z (- (* z (+ y 0.0007936500793651)) 0.0027777777777778)) 5e+143)
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/
(fma
(fma (+ y 0.0007936500793651) z -0.0027777777777778)
z
0.083333333333333)
x))
(+ (- (* x (log x)) x) (* (/ z (/ x z)) (+ y 0.0007936500793651)))))
double code(double x, double y, double z) {
double tmp;
if ((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) <= 5e+143) {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (fma(fma((y + 0.0007936500793651), z, -0.0027777777777778), z, 0.083333333333333) / x);
} else {
tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651));
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(z * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778)) <= 5e+143) tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(fma(fma(Float64(y + 0.0007936500793651), z, -0.0027777777777778), z, 0.083333333333333) / x)); else tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(Float64(z / Float64(x / z)) * Float64(y + 0.0007936500793651))); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(z * N[(N[(z * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision] - 0.0027777777777778), $MachinePrecision]), $MachinePrecision], 5e+143], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(y + 0.0007936500793651), $MachinePrecision] * z + -0.0027777777777778), $MachinePrecision] * z + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision] * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot \left(z \cdot \left(y + 0.0007936500793651\right) - 0.0027777777777778\right) \leq 5 \cdot 10^{+143}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{\mathsf{fma}\left(\mathsf{fma}\left(y + 0.0007936500793651, z, -0.0027777777777778\right), z, 0.083333333333333\right)}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot \log x - x\right) + \frac{z}{\frac{x}{z}} \cdot \left(y + 0.0007936500793651\right)\\
\end{array}
\end{array}
if (*.f64 (-.f64 (*.f64 (+.f64 y 7936500793651/10000000000000000) z) 13888888888889/5000000000000000) z) < 5.00000000000000012e143Initial program 99.5%
sub-neg99.5%
metadata-eval99.5%
fma-def99.5%
fma-neg99.5%
metadata-eval99.5%
Simplified99.5%
if 5.00000000000000012e143 < (*.f64 (-.f64 (*.f64 (+.f64 y 7936500793651/10000000000000000) z) 13888888888889/5000000000000000) z) Initial program 86.4%
sub-neg86.4%
metadata-eval86.4%
fma-def86.4%
fma-neg86.4%
metadata-eval86.4%
Simplified86.4%
Taylor expanded in x around inf 86.4%
sub-neg86.4%
mul-1-neg86.4%
log-rec86.4%
remove-double-neg86.4%
metadata-eval86.4%
distribute-rgt-in86.4%
*-rgt-identity86.4%
neg-mul-186.4%
*-rgt-identity86.4%
sub-neg86.4%
*-commutative86.4%
Simplified86.4%
Taylor expanded in x around 0 86.4%
Taylor expanded in z around inf 86.4%
associate-*l/90.1%
unpow290.1%
associate-/l*99.8%
Simplified99.8%
Final simplification99.6%
(FPCore (x y z)
:precision binary64
(if (<= x 128000000000.0)
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/
(fma
(fma (+ y 0.0007936500793651) z -0.0027777777777778)
z
0.083333333333333)
x))
(+
(- (* x (log x)) x)
(fma
z
(* z (+ (/ 0.0007936500793651 x) (/ y x)))
(/ (fma -0.0027777777777778 z 0.083333333333333) x)))))
double code(double x, double y, double z) {
double tmp;
if (x <= 128000000000.0) {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (fma(fma((y + 0.0007936500793651), z, -0.0027777777777778), z, 0.083333333333333) / x);
} else {
tmp = ((x * log(x)) - x) + fma(z, (z * ((0.0007936500793651 / x) + (y / x))), (fma(-0.0027777777777778, z, 0.083333333333333) / x));
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= 128000000000.0) tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(fma(fma(Float64(y + 0.0007936500793651), z, -0.0027777777777778), z, 0.083333333333333) / x)); else tmp = Float64(Float64(Float64(x * log(x)) - x) + fma(z, Float64(z * Float64(Float64(0.0007936500793651 / x) + Float64(y / x))), Float64(fma(-0.0027777777777778, z, 0.083333333333333) / x))); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, 128000000000.0], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(y + 0.0007936500793651), $MachinePrecision] * z + -0.0027777777777778), $MachinePrecision] * z + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(z * N[(z * N[(N[(0.0007936500793651 / x), $MachinePrecision] + N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(-0.0027777777777778 * z + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 128000000000:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{\mathsf{fma}\left(\mathsf{fma}\left(y + 0.0007936500793651, z, -0.0027777777777778\right), z, 0.083333333333333\right)}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot \log x - x\right) + \mathsf{fma}\left(z, z \cdot \left(\frac{0.0007936500793651}{x} + \frac{y}{x}\right), \frac{\mathsf{fma}\left(-0.0027777777777778, z, 0.083333333333333\right)}{x}\right)\\
\end{array}
\end{array}
if x < 1.28e11Initial program 99.6%
sub-neg99.6%
metadata-eval99.6%
fma-def99.7%
fma-neg99.7%
metadata-eval99.7%
Simplified99.7%
if 1.28e11 < x Initial program 91.0%
sub-neg91.0%
metadata-eval91.0%
fma-def91.0%
fma-neg91.0%
metadata-eval91.0%
Simplified91.0%
Taylor expanded in x around inf 91.1%
sub-neg91.1%
mul-1-neg91.1%
log-rec91.1%
remove-double-neg91.1%
metadata-eval91.1%
distribute-rgt-in91.0%
*-rgt-identity91.0%
neg-mul-191.0%
*-rgt-identity91.0%
sub-neg91.0%
*-commutative91.0%
Simplified91.0%
Taylor expanded in x around 0 91.0%
Taylor expanded in z around 0 93.4%
+-commutative93.4%
associate-*r/93.4%
metadata-eval93.4%
associate-+l+93.4%
unpow293.4%
associate-*l*99.6%
+-commutative99.6%
metadata-eval99.6%
associate-*r/99.6%
fma-def99.6%
associate-*r/99.6%
metadata-eval99.6%
Simplified99.6%
Final simplification99.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* z (- (* z (+ y 0.0007936500793651)) 0.0027777777777778))))
(if (<= t_0 5e+143)
(+
(+ 0.91893853320467 (- (* (log x) (- x 0.5)) x))
(/ (+ t_0 0.083333333333333) x))
(+ (- (* x (log x)) x) (* (/ z (/ x z)) (+ y 0.0007936500793651))))))
double code(double x, double y, double z) {
double t_0 = z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778);
double tmp;
if (t_0 <= 5e+143) {
tmp = (0.91893853320467 + ((log(x) * (x - 0.5)) - x)) + ((t_0 + 0.083333333333333) / x);
} else {
tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651));
}
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 = z * ((z * (y + 0.0007936500793651d0)) - 0.0027777777777778d0)
if (t_0 <= 5d+143) then
tmp = (0.91893853320467d0 + ((log(x) * (x - 0.5d0)) - x)) + ((t_0 + 0.083333333333333d0) / x)
else
tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651d0))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778);
double tmp;
if (t_0 <= 5e+143) {
tmp = (0.91893853320467 + ((Math.log(x) * (x - 0.5)) - x)) + ((t_0 + 0.083333333333333) / x);
} else {
tmp = ((x * Math.log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651));
}
return tmp;
}
def code(x, y, z): t_0 = z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778) tmp = 0 if t_0 <= 5e+143: tmp = (0.91893853320467 + ((math.log(x) * (x - 0.5)) - x)) + ((t_0 + 0.083333333333333) / x) else: tmp = ((x * math.log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651)) return tmp
function code(x, y, z) t_0 = Float64(z * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778)) tmp = 0.0 if (t_0 <= 5e+143) tmp = Float64(Float64(0.91893853320467 + Float64(Float64(log(x) * Float64(x - 0.5)) - x)) + Float64(Float64(t_0 + 0.083333333333333) / x)); else tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(Float64(z / Float64(x / z)) * Float64(y + 0.0007936500793651))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778); tmp = 0.0; if (t_0 <= 5e+143) tmp = (0.91893853320467 + ((log(x) * (x - 0.5)) - x)) + ((t_0 + 0.083333333333333) / x); else tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[(N[(z * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision] - 0.0027777777777778), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 5e+143], N[(N[(0.91893853320467 + N[(N[(N[Log[x], $MachinePrecision] * N[(x - 0.5), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(N[(t$95$0 + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision] * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \left(z \cdot \left(y + 0.0007936500793651\right) - 0.0027777777777778\right)\\
\mathbf{if}\;t_0 \leq 5 \cdot 10^{+143}:\\
\;\;\;\;\left(0.91893853320467 + \left(\log x \cdot \left(x - 0.5\right) - x\right)\right) + \frac{t_0 + 0.083333333333333}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot \log x - x\right) + \frac{z}{\frac{x}{z}} \cdot \left(y + 0.0007936500793651\right)\\
\end{array}
\end{array}
if (*.f64 (-.f64 (*.f64 (+.f64 y 7936500793651/10000000000000000) z) 13888888888889/5000000000000000) z) < 5.00000000000000012e143Initial program 99.5%
if 5.00000000000000012e143 < (*.f64 (-.f64 (*.f64 (+.f64 y 7936500793651/10000000000000000) z) 13888888888889/5000000000000000) z) Initial program 86.4%
sub-neg86.4%
metadata-eval86.4%
fma-def86.4%
fma-neg86.4%
metadata-eval86.4%
Simplified86.4%
Taylor expanded in x around inf 86.4%
sub-neg86.4%
mul-1-neg86.4%
log-rec86.4%
remove-double-neg86.4%
metadata-eval86.4%
distribute-rgt-in86.4%
*-rgt-identity86.4%
neg-mul-186.4%
*-rgt-identity86.4%
sub-neg86.4%
*-commutative86.4%
Simplified86.4%
Taylor expanded in x around 0 86.4%
Taylor expanded in z around inf 86.4%
associate-*l/90.1%
unpow290.1%
associate-/l*99.8%
Simplified99.8%
Final simplification99.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (* x (log x)) x)))
(if (<= z -5.8e+219)
(+ t_0 (* z (* z (/ 0.0007936500793651 x))))
(if (<= z -2.6e-53)
(+ t_0 (/ y (/ x (* z z))))
(if (<= z 4.5e-70)
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 1.0 (* x 12.000000000000048)))
(+ t_0 (* z (* z (/ y x)))))))))
double code(double x, double y, double z) {
double t_0 = (x * log(x)) - x;
double tmp;
if (z <= -5.8e+219) {
tmp = t_0 + (z * (z * (0.0007936500793651 / x)));
} else if (z <= -2.6e-53) {
tmp = t_0 + (y / (x / (z * z)));
} else if (z <= 4.5e-70) {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (1.0 / (x * 12.000000000000048));
} else {
tmp = t_0 + (z * (z * (y / 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)) - x
if (z <= (-5.8d+219)) then
tmp = t_0 + (z * (z * (0.0007936500793651d0 / x)))
else if (z <= (-2.6d-53)) then
tmp = t_0 + (y / (x / (z * z)))
else if (z <= 4.5d-70) then
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (1.0d0 / (x * 12.000000000000048d0))
else
tmp = t_0 + (z * (z * (y / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = (x * Math.log(x)) - x;
double tmp;
if (z <= -5.8e+219) {
tmp = t_0 + (z * (z * (0.0007936500793651 / x)));
} else if (z <= -2.6e-53) {
tmp = t_0 + (y / (x / (z * z)));
} else if (z <= 4.5e-70) {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (1.0 / (x * 12.000000000000048));
} else {
tmp = t_0 + (z * (z * (y / x)));
}
return tmp;
}
def code(x, y, z): t_0 = (x * math.log(x)) - x tmp = 0 if z <= -5.8e+219: tmp = t_0 + (z * (z * (0.0007936500793651 / x))) elif z <= -2.6e-53: tmp = t_0 + (y / (x / (z * z))) elif z <= 4.5e-70: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (1.0 / (x * 12.000000000000048)) else: tmp = t_0 + (z * (z * (y / x))) return tmp
function code(x, y, z) t_0 = Float64(Float64(x * log(x)) - x) tmp = 0.0 if (z <= -5.8e+219) tmp = Float64(t_0 + Float64(z * Float64(z * Float64(0.0007936500793651 / x)))); elseif (z <= -2.6e-53) tmp = Float64(t_0 + Float64(y / Float64(x / Float64(z * z)))); elseif (z <= 4.5e-70) tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(1.0 / Float64(x * 12.000000000000048))); else tmp = Float64(t_0 + Float64(z * Float64(z * Float64(y / x)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = (x * log(x)) - x; tmp = 0.0; if (z <= -5.8e+219) tmp = t_0 + (z * (z * (0.0007936500793651 / x))); elseif (z <= -2.6e-53) tmp = t_0 + (y / (x / (z * z))); elseif (z <= 4.5e-70) tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (1.0 / (x * 12.000000000000048)); else tmp = t_0 + (z * (z * (y / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]}, If[LessEqual[z, -5.8e+219], N[(t$95$0 + N[(z * N[(z * N[(0.0007936500793651 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.6e-53], N[(t$95$0 + N[(y / N[(x / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.5e-70], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(x * 12.000000000000048), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(z * N[(z * N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \log x - x\\
\mathbf{if}\;z \leq -5.8 \cdot 10^{+219}:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{0.0007936500793651}{x}\right)\\
\mathbf{elif}\;z \leq -2.6 \cdot 10^{-53}:\\
\;\;\;\;t_0 + \frac{y}{\frac{x}{z \cdot z}}\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{-70}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{1}{x \cdot 12.000000000000048}\\
\mathbf{else}:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{y}{x}\right)\\
\end{array}
\end{array}
if z < -5.79999999999999958e219Initial program 81.7%
sub-neg81.7%
metadata-eval81.7%
fma-def81.7%
fma-neg81.7%
metadata-eval81.7%
Simplified81.7%
Taylor expanded in x around inf 81.7%
sub-neg81.7%
mul-1-neg81.7%
log-rec81.7%
remove-double-neg81.7%
metadata-eval81.7%
distribute-rgt-in81.7%
*-rgt-identity81.7%
neg-mul-181.7%
*-rgt-identity81.7%
sub-neg81.7%
*-commutative81.7%
Simplified81.7%
Taylor expanded in y around 0 68.4%
fma-neg68.4%
metadata-eval68.4%
Simplified68.4%
Taylor expanded in z around inf 68.4%
*-commutative68.4%
associate-*l/68.4%
associate-*r/68.4%
metadata-eval68.4%
associate-*r/68.4%
unpow268.4%
associate-*l*84.9%
associate-*r/84.9%
metadata-eval84.9%
Simplified84.9%
if -5.79999999999999958e219 < z < -2.59999999999999996e-53Initial program 94.8%
sub-neg94.8%
metadata-eval94.8%
fma-def94.9%
fma-neg94.9%
metadata-eval94.9%
Simplified94.9%
Taylor expanded in x around inf 95.0%
sub-neg95.0%
mul-1-neg95.0%
log-rec95.0%
remove-double-neg95.0%
metadata-eval95.0%
distribute-rgt-in94.9%
*-rgt-identity94.9%
neg-mul-194.9%
*-rgt-identity94.9%
sub-neg94.9%
*-commutative94.9%
Simplified94.9%
Taylor expanded in y around inf 72.6%
associate-/l*75.9%
unpow275.9%
Simplified75.9%
if -2.59999999999999996e-53 < z < 4.50000000000000022e-70Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in z around 0 97.8%
clear-num96.8%
inv-pow96.8%
div-inv96.9%
metadata-eval96.9%
Applied egg-rr97.9%
unpow-196.9%
Simplified97.9%
if 4.50000000000000022e-70 < z Initial program 93.2%
sub-neg93.2%
metadata-eval93.2%
fma-def93.2%
fma-neg93.1%
metadata-eval93.1%
Simplified93.1%
Taylor expanded in x around inf 93.1%
sub-neg93.1%
mul-1-neg93.1%
log-rec93.1%
remove-double-neg93.1%
metadata-eval93.1%
distribute-rgt-in93.1%
*-rgt-identity93.1%
neg-mul-193.1%
*-rgt-identity93.1%
sub-neg93.1%
*-commutative93.1%
Simplified93.1%
metadata-eval93.1%
fma-neg93.2%
fma-def93.2%
*-un-lft-identity93.2%
add-sqr-sqrt93.0%
times-frac93.1%
*-commutative93.1%
fma-udef93.1%
fma-neg93.1%
metadata-eval93.1%
Applied egg-rr93.1%
Taylor expanded in y around inf 69.2%
unpow269.2%
*-commutative69.2%
associate-*r/70.4%
associate-*l*73.4%
Simplified73.4%
Final simplification85.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (* x (log x)) x)))
(if (<= x 100000000000.0)
(+
t_0
(/
(+
(* z (- (* z (+ y 0.0007936500793651)) 0.0027777777777778))
0.083333333333333)
x))
(+ t_0 (* (/ z (/ x z)) (+ y 0.0007936500793651))))))
double code(double x, double y, double z) {
double t_0 = (x * log(x)) - x;
double tmp;
if (x <= 100000000000.0) {
tmp = t_0 + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x);
} else {
tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651));
}
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)) - x
if (x <= 100000000000.0d0) then
tmp = t_0 + (((z * ((z * (y + 0.0007936500793651d0)) - 0.0027777777777778d0)) + 0.083333333333333d0) / x)
else
tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651d0))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = (x * Math.log(x)) - x;
double tmp;
if (x <= 100000000000.0) {
tmp = t_0 + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x);
} else {
tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651));
}
return tmp;
}
def code(x, y, z): t_0 = (x * math.log(x)) - x tmp = 0 if x <= 100000000000.0: tmp = t_0 + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x) else: tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651)) return tmp
function code(x, y, z) t_0 = Float64(Float64(x * log(x)) - x) tmp = 0.0 if (x <= 100000000000.0) tmp = Float64(t_0 + Float64(Float64(Float64(z * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x)); else tmp = Float64(t_0 + Float64(Float64(z / Float64(x / z)) * Float64(y + 0.0007936500793651))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = (x * log(x)) - x; tmp = 0.0; if (x <= 100000000000.0) tmp = t_0 + (((z * ((z * (y + 0.0007936500793651)) - 0.0027777777777778)) + 0.083333333333333) / x); else tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651)); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]}, If[LessEqual[x, 100000000000.0], N[(t$95$0 + N[(N[(N[(z * N[(N[(z * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision] - 0.0027777777777778), $MachinePrecision]), $MachinePrecision] + 0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision] * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \log x - x\\
\mathbf{if}\;x \leq 100000000000:\\
\;\;\;\;t_0 + \frac{z \cdot \left(z \cdot \left(y + 0.0007936500793651\right) - 0.0027777777777778\right) + 0.083333333333333}{x}\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{z}{\frac{x}{z}} \cdot \left(y + 0.0007936500793651\right)\\
\end{array}
\end{array}
if x < 1e11Initial program 99.6%
sub-neg99.6%
metadata-eval99.6%
fma-def99.7%
fma-neg99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around inf 98.8%
sub-neg98.8%
mul-1-neg98.8%
log-rec98.8%
remove-double-neg98.8%
metadata-eval98.8%
distribute-rgt-in98.8%
*-rgt-identity98.8%
neg-mul-198.8%
*-rgt-identity98.8%
sub-neg98.8%
*-commutative98.8%
Simplified98.8%
Taylor expanded in x around 0 98.7%
if 1e11 < x Initial program 91.0%
sub-neg91.0%
metadata-eval91.0%
fma-def91.0%
fma-neg91.0%
metadata-eval91.0%
Simplified91.0%
Taylor expanded in x around inf 91.1%
sub-neg91.1%
mul-1-neg91.1%
log-rec91.1%
remove-double-neg91.1%
metadata-eval91.1%
distribute-rgt-in91.0%
*-rgt-identity91.0%
neg-mul-191.0%
*-rgt-identity91.0%
sub-neg91.0%
*-commutative91.0%
Simplified91.0%
Taylor expanded in x around 0 91.0%
Taylor expanded in z around inf 91.0%
associate-*l/93.3%
unpow293.3%
associate-/l*99.6%
Simplified99.6%
Final simplification99.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (* x (log x)) x)))
(if (<= z -1.65e+218)
(+ t_0 (* z (* z (/ 0.0007936500793651 x))))
(if (or (<= z -1.16e-52) (not (<= z 6e-70)))
(+ t_0 (* z (* z (/ y x))))
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 0.083333333333333 x))))))
double code(double x, double y, double z) {
double t_0 = (x * log(x)) - x;
double tmp;
if (z <= -1.65e+218) {
tmp = t_0 + (z * (z * (0.0007936500793651 / x)));
} else if ((z <= -1.16e-52) || !(z <= 6e-70)) {
tmp = t_0 + (z * (z * (y / x)));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (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)) - x
if (z <= (-1.65d+218)) then
tmp = t_0 + (z * (z * (0.0007936500793651d0 / x)))
else if ((z <= (-1.16d-52)) .or. (.not. (z <= 6d-70))) then
tmp = t_0 + (z * (z * (y / x)))
else
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (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)) - x;
double tmp;
if (z <= -1.65e+218) {
tmp = t_0 + (z * (z * (0.0007936500793651 / x)));
} else if ((z <= -1.16e-52) || !(z <= 6e-70)) {
tmp = t_0 + (z * (z * (y / x)));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (0.083333333333333 / x);
}
return tmp;
}
def code(x, y, z): t_0 = (x * math.log(x)) - x tmp = 0 if z <= -1.65e+218: tmp = t_0 + (z * (z * (0.0007936500793651 / x))) elif (z <= -1.16e-52) or not (z <= 6e-70): tmp = t_0 + (z * (z * (y / x))) else: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (0.083333333333333 / x) return tmp
function code(x, y, z) t_0 = Float64(Float64(x * log(x)) - x) tmp = 0.0 if (z <= -1.65e+218) tmp = Float64(t_0 + Float64(z * Float64(z * Float64(0.0007936500793651 / x)))); elseif ((z <= -1.16e-52) || !(z <= 6e-70)) tmp = Float64(t_0 + Float64(z * Float64(z * Float64(y / x)))); else tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(0.083333333333333 / x)); end return tmp end
function tmp_2 = code(x, y, z) t_0 = (x * log(x)) - x; tmp = 0.0; if (z <= -1.65e+218) tmp = t_0 + (z * (z * (0.0007936500793651 / x))); elseif ((z <= -1.16e-52) || ~((z <= 6e-70))) tmp = t_0 + (z * (z * (y / x))); else tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (0.083333333333333 / x); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]}, If[LessEqual[z, -1.65e+218], N[(t$95$0 + N[(z * N[(z * N[(0.0007936500793651 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -1.16e-52], N[Not[LessEqual[z, 6e-70]], $MachinePrecision]], N[(t$95$0 + N[(z * N[(z * N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \log x - x\\
\mathbf{if}\;z \leq -1.65 \cdot 10^{+218}:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{0.0007936500793651}{x}\right)\\
\mathbf{elif}\;z \leq -1.16 \cdot 10^{-52} \lor \neg \left(z \leq 6 \cdot 10^{-70}\right):\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{y}{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{0.083333333333333}{x}\\
\end{array}
\end{array}
if z < -1.64999999999999999e218Initial program 81.7%
sub-neg81.7%
metadata-eval81.7%
fma-def81.7%
fma-neg81.7%
metadata-eval81.7%
Simplified81.7%
Taylor expanded in x around inf 81.7%
sub-neg81.7%
mul-1-neg81.7%
log-rec81.7%
remove-double-neg81.7%
metadata-eval81.7%
distribute-rgt-in81.7%
*-rgt-identity81.7%
neg-mul-181.7%
*-rgt-identity81.7%
sub-neg81.7%
*-commutative81.7%
Simplified81.7%
Taylor expanded in y around 0 68.4%
fma-neg68.4%
metadata-eval68.4%
Simplified68.4%
Taylor expanded in z around inf 68.4%
*-commutative68.4%
associate-*l/68.4%
associate-*r/68.4%
metadata-eval68.4%
associate-*r/68.4%
unpow268.4%
associate-*l*84.9%
associate-*r/84.9%
metadata-eval84.9%
Simplified84.9%
if -1.64999999999999999e218 < z < -1.1599999999999999e-52 or 6.0000000000000003e-70 < z Initial program 93.9%
sub-neg93.9%
metadata-eval93.9%
fma-def93.9%
fma-neg93.9%
metadata-eval93.9%
Simplified93.9%
Taylor expanded in x around inf 94.0%
sub-neg94.0%
mul-1-neg94.0%
log-rec94.0%
remove-double-neg94.0%
metadata-eval94.0%
distribute-rgt-in93.9%
*-rgt-identity93.9%
neg-mul-193.9%
*-rgt-identity93.9%
sub-neg93.9%
*-commutative93.9%
Simplified93.9%
metadata-eval93.9%
fma-neg93.9%
fma-def93.9%
*-un-lft-identity93.9%
add-sqr-sqrt93.8%
times-frac93.8%
*-commutative93.8%
fma-udef93.8%
fma-neg93.8%
metadata-eval93.8%
Applied egg-rr93.8%
Taylor expanded in y around inf 70.7%
unpow270.7%
*-commutative70.7%
associate-*r/72.1%
associate-*l*74.5%
Simplified74.5%
if -1.1599999999999999e-52 < z < 6.0000000000000003e-70Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in z around 0 97.8%
Final simplification85.6%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (* x (log x)) x)))
(if (<= z -3.35e+220)
(+ t_0 (* z (* z (/ 0.0007936500793651 x))))
(if (<= z -2.15e-52)
(+ t_0 (/ y (/ x (* z z))))
(if (<= z 5.4e-72)
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 0.083333333333333 x))
(+ t_0 (* z (* z (/ y x)))))))))
double code(double x, double y, double z) {
double t_0 = (x * log(x)) - x;
double tmp;
if (z <= -3.35e+220) {
tmp = t_0 + (z * (z * (0.0007936500793651 / x)));
} else if (z <= -2.15e-52) {
tmp = t_0 + (y / (x / (z * z)));
} else if (z <= 5.4e-72) {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (0.083333333333333 / x);
} else {
tmp = t_0 + (z * (z * (y / 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)) - x
if (z <= (-3.35d+220)) then
tmp = t_0 + (z * (z * (0.0007936500793651d0 / x)))
else if (z <= (-2.15d-52)) then
tmp = t_0 + (y / (x / (z * z)))
else if (z <= 5.4d-72) then
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (0.083333333333333d0 / x)
else
tmp = t_0 + (z * (z * (y / x)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = (x * Math.log(x)) - x;
double tmp;
if (z <= -3.35e+220) {
tmp = t_0 + (z * (z * (0.0007936500793651 / x)));
} else if (z <= -2.15e-52) {
tmp = t_0 + (y / (x / (z * z)));
} else if (z <= 5.4e-72) {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (0.083333333333333 / x);
} else {
tmp = t_0 + (z * (z * (y / x)));
}
return tmp;
}
def code(x, y, z): t_0 = (x * math.log(x)) - x tmp = 0 if z <= -3.35e+220: tmp = t_0 + (z * (z * (0.0007936500793651 / x))) elif z <= -2.15e-52: tmp = t_0 + (y / (x / (z * z))) elif z <= 5.4e-72: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (0.083333333333333 / x) else: tmp = t_0 + (z * (z * (y / x))) return tmp
function code(x, y, z) t_0 = Float64(Float64(x * log(x)) - x) tmp = 0.0 if (z <= -3.35e+220) tmp = Float64(t_0 + Float64(z * Float64(z * Float64(0.0007936500793651 / x)))); elseif (z <= -2.15e-52) tmp = Float64(t_0 + Float64(y / Float64(x / Float64(z * z)))); elseif (z <= 5.4e-72) tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(0.083333333333333 / x)); else tmp = Float64(t_0 + Float64(z * Float64(z * Float64(y / x)))); end return tmp end
function tmp_2 = code(x, y, z) t_0 = (x * log(x)) - x; tmp = 0.0; if (z <= -3.35e+220) tmp = t_0 + (z * (z * (0.0007936500793651 / x))); elseif (z <= -2.15e-52) tmp = t_0 + (y / (x / (z * z))); elseif (z <= 5.4e-72) tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (0.083333333333333 / x); else tmp = t_0 + (z * (z * (y / x))); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]}, If[LessEqual[z, -3.35e+220], N[(t$95$0 + N[(z * N[(z * N[(0.0007936500793651 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.15e-52], N[(t$95$0 + N[(y / N[(x / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.4e-72], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(z * N[(z * N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \log x - x\\
\mathbf{if}\;z \leq -3.35 \cdot 10^{+220}:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{0.0007936500793651}{x}\right)\\
\mathbf{elif}\;z \leq -2.15 \cdot 10^{-52}:\\
\;\;\;\;t_0 + \frac{y}{\frac{x}{z \cdot z}}\\
\mathbf{elif}\;z \leq 5.4 \cdot 10^{-72}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{0.083333333333333}{x}\\
\mathbf{else}:\\
\;\;\;\;t_0 + z \cdot \left(z \cdot \frac{y}{x}\right)\\
\end{array}
\end{array}
if z < -3.3499999999999999e220Initial program 81.7%
sub-neg81.7%
metadata-eval81.7%
fma-def81.7%
fma-neg81.7%
metadata-eval81.7%
Simplified81.7%
Taylor expanded in x around inf 81.7%
sub-neg81.7%
mul-1-neg81.7%
log-rec81.7%
remove-double-neg81.7%
metadata-eval81.7%
distribute-rgt-in81.7%
*-rgt-identity81.7%
neg-mul-181.7%
*-rgt-identity81.7%
sub-neg81.7%
*-commutative81.7%
Simplified81.7%
Taylor expanded in y around 0 68.4%
fma-neg68.4%
metadata-eval68.4%
Simplified68.4%
Taylor expanded in z around inf 68.4%
*-commutative68.4%
associate-*l/68.4%
associate-*r/68.4%
metadata-eval68.4%
associate-*r/68.4%
unpow268.4%
associate-*l*84.9%
associate-*r/84.9%
metadata-eval84.9%
Simplified84.9%
if -3.3499999999999999e220 < z < -2.1500000000000002e-52Initial program 94.8%
sub-neg94.8%
metadata-eval94.8%
fma-def94.9%
fma-neg94.9%
metadata-eval94.9%
Simplified94.9%
Taylor expanded in x around inf 95.0%
sub-neg95.0%
mul-1-neg95.0%
log-rec95.0%
remove-double-neg95.0%
metadata-eval95.0%
distribute-rgt-in94.9%
*-rgt-identity94.9%
neg-mul-194.9%
*-rgt-identity94.9%
sub-neg94.9%
*-commutative94.9%
Simplified94.9%
Taylor expanded in y around inf 72.6%
associate-/l*75.9%
unpow275.9%
Simplified75.9%
if -2.1500000000000002e-52 < z < 5.4e-72Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in z around 0 97.8%
if 5.4e-72 < z Initial program 93.2%
sub-neg93.2%
metadata-eval93.2%
fma-def93.2%
fma-neg93.1%
metadata-eval93.1%
Simplified93.1%
Taylor expanded in x around inf 93.1%
sub-neg93.1%
mul-1-neg93.1%
log-rec93.1%
remove-double-neg93.1%
metadata-eval93.1%
distribute-rgt-in93.1%
*-rgt-identity93.1%
neg-mul-193.1%
*-rgt-identity93.1%
sub-neg93.1%
*-commutative93.1%
Simplified93.1%
metadata-eval93.1%
fma-neg93.2%
fma-def93.2%
*-un-lft-identity93.2%
add-sqr-sqrt93.0%
times-frac93.1%
*-commutative93.1%
fma-udef93.1%
fma-neg93.1%
metadata-eval93.1%
Applied egg-rr93.1%
Taylor expanded in y around inf 69.2%
unpow269.2%
*-commutative69.2%
associate-*r/70.4%
associate-*l*73.4%
Simplified73.4%
Final simplification85.6%
(FPCore (x y z)
:precision binary64
(if (or (<= z -2.4e-52) (not (<= z 8e-70)))
(+ (- (* x (log x)) x) (* (* z z) (/ (+ y 0.0007936500793651) x)))
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 1.0 (* x 12.000000000000048)))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -2.4e-52) || !(z <= 8e-70)) {
tmp = ((x * log(x)) - x) + ((z * z) * ((y + 0.0007936500793651) / x));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (1.0 / (x * 12.000000000000048));
}
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.4d-52)) .or. (.not. (z <= 8d-70))) then
tmp = ((x * log(x)) - x) + ((z * z) * ((y + 0.0007936500793651d0) / x))
else
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (1.0d0 / (x * 12.000000000000048d0))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -2.4e-52) || !(z <= 8e-70)) {
tmp = ((x * Math.log(x)) - x) + ((z * z) * ((y + 0.0007936500793651) / x));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (1.0 / (x * 12.000000000000048));
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -2.4e-52) or not (z <= 8e-70): tmp = ((x * math.log(x)) - x) + ((z * z) * ((y + 0.0007936500793651) / x)) else: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (1.0 / (x * 12.000000000000048)) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -2.4e-52) || !(z <= 8e-70)) tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(Float64(z * z) * Float64(Float64(y + 0.0007936500793651) / x))); else tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(1.0 / Float64(x * 12.000000000000048))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -2.4e-52) || ~((z <= 8e-70))) tmp = ((x * log(x)) - x) + ((z * z) * ((y + 0.0007936500793651) / x)); else tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (1.0 / (x * 12.000000000000048)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -2.4e-52], N[Not[LessEqual[z, 8e-70]], $MachinePrecision]], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(N[(z * z), $MachinePrecision] * N[(N[(y + 0.0007936500793651), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(x * 12.000000000000048), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.4 \cdot 10^{-52} \lor \neg \left(z \leq 8 \cdot 10^{-70}\right):\\
\;\;\;\;\left(x \cdot \log x - x\right) + \left(z \cdot z\right) \cdot \frac{y + 0.0007936500793651}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{1}{x \cdot 12.000000000000048}\\
\end{array}
\end{array}
if z < -2.4000000000000002e-52 or 7.99999999999999997e-70 < z Initial program 92.6%
sub-neg92.6%
metadata-eval92.6%
fma-def92.6%
fma-neg92.6%
metadata-eval92.6%
Simplified92.6%
Taylor expanded in x around inf 92.7%
sub-neg92.7%
mul-1-neg92.7%
log-rec92.7%
remove-double-neg92.7%
metadata-eval92.7%
distribute-rgt-in92.6%
*-rgt-identity92.6%
neg-mul-192.6%
*-rgt-identity92.6%
sub-neg92.6%
*-commutative92.6%
Simplified92.6%
Taylor expanded in z around inf 90.1%
*-lft-identity90.1%
times-frac91.4%
/-rgt-identity91.4%
unpow291.4%
Simplified91.4%
if -2.4000000000000002e-52 < z < 7.99999999999999997e-70Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in z around 0 97.8%
clear-num96.8%
inv-pow96.8%
div-inv96.9%
metadata-eval96.9%
Applied egg-rr97.9%
unpow-196.9%
Simplified97.9%
Final simplification94.3%
(FPCore (x y z)
:precision binary64
(if (or (<= z -2.5e-53) (not (<= z 8e-70)))
(+ (- (* x (log x)) x) (* (/ z (/ x z)) (+ y 0.0007936500793651)))
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 1.0 (* x 12.000000000000048)))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -2.5e-53) || !(z <= 8e-70)) {
tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (1.0 / (x * 12.000000000000048));
}
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.5d-53)) .or. (.not. (z <= 8d-70))) then
tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651d0))
else
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (1.0d0 / (x * 12.000000000000048d0))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -2.5e-53) || !(z <= 8e-70)) {
tmp = ((x * Math.log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (1.0 / (x * 12.000000000000048));
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -2.5e-53) or not (z <= 8e-70): tmp = ((x * math.log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651)) else: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (1.0 / (x * 12.000000000000048)) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -2.5e-53) || !(z <= 8e-70)) tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(Float64(z / Float64(x / z)) * Float64(y + 0.0007936500793651))); else tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(1.0 / Float64(x * 12.000000000000048))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -2.5e-53) || ~((z <= 8e-70))) tmp = ((x * log(x)) - x) + ((z / (x / z)) * (y + 0.0007936500793651)); else tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (1.0 / (x * 12.000000000000048)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -2.5e-53], N[Not[LessEqual[z, 8e-70]], $MachinePrecision]], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision] * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(x * 12.000000000000048), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.5 \cdot 10^{-53} \lor \neg \left(z \leq 8 \cdot 10^{-70}\right):\\
\;\;\;\;\left(x \cdot \log x - x\right) + \frac{z}{\frac{x}{z}} \cdot \left(y + 0.0007936500793651\right)\\
\mathbf{else}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{1}{x \cdot 12.000000000000048}\\
\end{array}
\end{array}
if z < -2.5e-53 or 7.99999999999999997e-70 < z Initial program 92.6%
sub-neg92.6%
metadata-eval92.6%
fma-def92.6%
fma-neg92.6%
metadata-eval92.6%
Simplified92.6%
Taylor expanded in x around inf 92.7%
sub-neg92.7%
mul-1-neg92.7%
log-rec92.7%
remove-double-neg92.7%
metadata-eval92.7%
distribute-rgt-in92.6%
*-rgt-identity92.6%
neg-mul-192.6%
*-rgt-identity92.6%
sub-neg92.6%
*-commutative92.6%
Simplified92.6%
Taylor expanded in x around 0 92.6%
Taylor expanded in z around inf 90.1%
associate-*l/92.1%
unpow292.1%
associate-/l*97.3%
Simplified97.3%
if -2.5e-53 < z < 7.99999999999999997e-70Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in z around 0 97.8%
clear-num96.8%
inv-pow96.8%
div-inv96.9%
metadata-eval96.9%
Applied egg-rr97.9%
unpow-196.9%
Simplified97.9%
Final simplification97.5%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (* x (log x)) x)))
(if (or (<= z -6.8e-29) (not (<= z 9.8)))
(+ t_0 (* (/ z (/ x z)) (+ y 0.0007936500793651)))
(+ t_0 (/ (+ 0.083333333333333 (* z (* y z))) x)))))
double code(double x, double y, double z) {
double t_0 = (x * log(x)) - x;
double tmp;
if ((z <= -6.8e-29) || !(z <= 9.8)) {
tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651));
} else {
tmp = t_0 + ((0.083333333333333 + (z * (y * 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)) - x
if ((z <= (-6.8d-29)) .or. (.not. (z <= 9.8d0))) then
tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651d0))
else
tmp = t_0 + ((0.083333333333333d0 + (z * (y * 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)) - x;
double tmp;
if ((z <= -6.8e-29) || !(z <= 9.8)) {
tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651));
} else {
tmp = t_0 + ((0.083333333333333 + (z * (y * z))) / x);
}
return tmp;
}
def code(x, y, z): t_0 = (x * math.log(x)) - x tmp = 0 if (z <= -6.8e-29) or not (z <= 9.8): tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651)) else: tmp = t_0 + ((0.083333333333333 + (z * (y * z))) / x) return tmp
function code(x, y, z) t_0 = Float64(Float64(x * log(x)) - x) tmp = 0.0 if ((z <= -6.8e-29) || !(z <= 9.8)) tmp = Float64(t_0 + Float64(Float64(z / Float64(x / z)) * Float64(y + 0.0007936500793651))); else tmp = Float64(t_0 + Float64(Float64(0.083333333333333 + Float64(z * Float64(y * z))) / x)); end return tmp end
function tmp_2 = code(x, y, z) t_0 = (x * log(x)) - x; tmp = 0.0; if ((z <= -6.8e-29) || ~((z <= 9.8))) tmp = t_0 + ((z / (x / z)) * (y + 0.0007936500793651)); else tmp = t_0 + ((0.083333333333333 + (z * (y * z))) / x); end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]}, If[Or[LessEqual[z, -6.8e-29], N[Not[LessEqual[z, 9.8]], $MachinePrecision]], N[(t$95$0 + N[(N[(z / N[(x / z), $MachinePrecision]), $MachinePrecision] * N[(y + 0.0007936500793651), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(N[(0.083333333333333 + N[(z * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \log x - x\\
\mathbf{if}\;z \leq -6.8 \cdot 10^{-29} \lor \neg \left(z \leq 9.8\right):\\
\;\;\;\;t_0 + \frac{z}{\frac{x}{z}} \cdot \left(y + 0.0007936500793651\right)\\
\mathbf{else}:\\
\;\;\;\;t_0 + \frac{0.083333333333333 + z \cdot \left(y \cdot z\right)}{x}\\
\end{array}
\end{array}
if z < -6.79999999999999945e-29 or 9.8000000000000007 < z Initial program 92.0%
sub-neg92.0%
metadata-eval92.0%
fma-def92.0%
fma-neg92.0%
metadata-eval92.0%
Simplified92.0%
Taylor expanded in x around inf 92.0%
sub-neg92.0%
mul-1-neg92.0%
log-rec92.0%
remove-double-neg92.0%
metadata-eval92.0%
distribute-rgt-in92.0%
*-rgt-identity92.0%
neg-mul-192.0%
*-rgt-identity92.0%
sub-neg92.0%
*-commutative92.0%
Simplified92.0%
Taylor expanded in x around 0 92.0%
Taylor expanded in z around inf 90.6%
associate-*l/92.8%
unpow292.8%
associate-/l*98.4%
Simplified98.4%
if -6.79999999999999945e-29 < z < 9.8000000000000007Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in x around inf 98.5%
sub-neg98.5%
mul-1-neg98.5%
log-rec98.5%
remove-double-neg98.5%
metadata-eval98.5%
distribute-rgt-in98.5%
*-rgt-identity98.5%
neg-mul-198.5%
*-rgt-identity98.5%
sub-neg98.5%
*-commutative98.5%
Simplified98.5%
Taylor expanded in x around 0 98.5%
Taylor expanded in y around inf 98.0%
*-commutative98.0%
unpow298.0%
associate-*l*98.0%
Simplified98.0%
Final simplification98.2%
(FPCore (x y z)
:precision binary64
(if (or (<= z -36.0) (not (<= z 2.5e+14)))
(+ (- (* x (log x)) x) (* -0.0027777777777778 (/ z x)))
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 0.083333333333333 x))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -36.0) || !(z <= 2.5e+14)) {
tmp = ((x * log(x)) - x) + (-0.0027777777777778 * (z / x));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (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 <= (-36.0d0)) .or. (.not. (z <= 2.5d+14))) then
tmp = ((x * log(x)) - x) + ((-0.0027777777777778d0) * (z / x))
else
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (0.083333333333333d0 / x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -36.0) || !(z <= 2.5e+14)) {
tmp = ((x * Math.log(x)) - x) + (-0.0027777777777778 * (z / x));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (0.083333333333333 / x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -36.0) or not (z <= 2.5e+14): tmp = ((x * math.log(x)) - x) + (-0.0027777777777778 * (z / x)) else: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (0.083333333333333 / x) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -36.0) || !(z <= 2.5e+14)) tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(-0.0027777777777778 * Float64(z / x))); else tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(0.083333333333333 / x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -36.0) || ~((z <= 2.5e+14))) tmp = ((x * log(x)) - x) + (-0.0027777777777778 * (z / x)); else tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (0.083333333333333 / x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -36.0], N[Not[LessEqual[z, 2.5e+14]], $MachinePrecision]], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(-0.0027777777777778 * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -36 \lor \neg \left(z \leq 2.5 \cdot 10^{+14}\right):\\
\;\;\;\;\left(x \cdot \log x - x\right) + -0.0027777777777778 \cdot \frac{z}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{0.083333333333333}{x}\\
\end{array}
\end{array}
if z < -36 or 2.5e14 < z Initial program 91.3%
sub-neg91.3%
metadata-eval91.3%
fma-def91.3%
fma-neg91.3%
metadata-eval91.3%
Simplified91.3%
Taylor expanded in x around inf 91.3%
sub-neg91.3%
mul-1-neg91.3%
log-rec91.3%
remove-double-neg91.3%
metadata-eval91.3%
distribute-rgt-in91.3%
*-rgt-identity91.3%
neg-mul-191.3%
*-rgt-identity91.3%
sub-neg91.3%
*-commutative91.3%
Simplified91.3%
Taylor expanded in z around 0 32.3%
*-commutative32.3%
Simplified32.3%
Taylor expanded in z around inf 33.7%
if -36 < z < 2.5e14Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in z around 0 85.9%
Final simplification61.8%
(FPCore (x y z)
:precision binary64
(if (or (<= z -21.0) (not (<= z 140.0)))
(+ (- (* x (log x)) x) (* 0.0007936500793651 (/ (* z z) x)))
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 0.083333333333333 x))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -21.0) || !(z <= 140.0)) {
tmp = ((x * log(x)) - x) + (0.0007936500793651 * ((z * z) / x));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (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 <= (-21.0d0)) .or. (.not. (z <= 140.0d0))) then
tmp = ((x * log(x)) - x) + (0.0007936500793651d0 * ((z * z) / x))
else
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (0.083333333333333d0 / x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -21.0) || !(z <= 140.0)) {
tmp = ((x * Math.log(x)) - x) + (0.0007936500793651 * ((z * z) / x));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (0.083333333333333 / x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -21.0) or not (z <= 140.0): tmp = ((x * math.log(x)) - x) + (0.0007936500793651 * ((z * z) / x)) else: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (0.083333333333333 / x) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -21.0) || !(z <= 140.0)) tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(0.0007936500793651 * Float64(Float64(z * z) / x))); else tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(0.083333333333333 / x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -21.0) || ~((z <= 140.0))) tmp = ((x * log(x)) - x) + (0.0007936500793651 * ((z * z) / x)); else tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (0.083333333333333 / x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -21.0], N[Not[LessEqual[z, 140.0]], $MachinePrecision]], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(0.0007936500793651 * N[(N[(z * z), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -21 \lor \neg \left(z \leq 140\right):\\
\;\;\;\;\left(x \cdot \log x - x\right) + 0.0007936500793651 \cdot \frac{z \cdot z}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{0.083333333333333}{x}\\
\end{array}
\end{array}
if z < -21 or 140 < z Initial program 91.4%
sub-neg91.4%
metadata-eval91.4%
fma-def91.4%
fma-neg91.4%
metadata-eval91.4%
Simplified91.4%
Taylor expanded in x around inf 91.4%
sub-neg91.4%
mul-1-neg91.4%
log-rec91.4%
remove-double-neg91.4%
metadata-eval91.4%
distribute-rgt-in91.4%
*-rgt-identity91.4%
neg-mul-191.4%
*-rgt-identity91.4%
sub-neg91.4%
*-commutative91.4%
Simplified91.4%
Taylor expanded in y around 0 64.3%
fma-neg64.3%
metadata-eval64.3%
Simplified64.3%
Taylor expanded in z around inf 63.5%
unpow263.5%
Simplified63.5%
if -21 < z < 140Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in z around 0 86.4%
Final simplification75.8%
(FPCore (x y z)
:precision binary64
(if (or (<= z -12.5) (not (<= z 140.0)))
(+ (- (* x (log x)) x) (* z (* z (/ 0.0007936500793651 x))))
(+
(+ 0.91893853320467 (- (* (+ x -0.5) (log x)) x))
(/ 0.083333333333333 x))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -12.5) || !(z <= 140.0)) {
tmp = ((x * log(x)) - x) + (z * (z * (0.0007936500793651 / x)));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (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 <= (-12.5d0)) .or. (.not. (z <= 140.0d0))) then
tmp = ((x * log(x)) - x) + (z * (z * (0.0007936500793651d0 / x)))
else
tmp = (0.91893853320467d0 + (((x + (-0.5d0)) * log(x)) - x)) + (0.083333333333333d0 / x)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -12.5) || !(z <= 140.0)) {
tmp = ((x * Math.log(x)) - x) + (z * (z * (0.0007936500793651 / x)));
} else {
tmp = (0.91893853320467 + (((x + -0.5) * Math.log(x)) - x)) + (0.083333333333333 / x);
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -12.5) or not (z <= 140.0): tmp = ((x * math.log(x)) - x) + (z * (z * (0.0007936500793651 / x))) else: tmp = (0.91893853320467 + (((x + -0.5) * math.log(x)) - x)) + (0.083333333333333 / x) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -12.5) || !(z <= 140.0)) tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(z * Float64(z * Float64(0.0007936500793651 / x)))); else tmp = Float64(Float64(0.91893853320467 + Float64(Float64(Float64(x + -0.5) * log(x)) - x)) + Float64(0.083333333333333 / x)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -12.5) || ~((z <= 140.0))) tmp = ((x * log(x)) - x) + (z * (z * (0.0007936500793651 / x))); else tmp = (0.91893853320467 + (((x + -0.5) * log(x)) - x)) + (0.083333333333333 / x); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -12.5], N[Not[LessEqual[z, 140.0]], $MachinePrecision]], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(z * N[(z * N[(0.0007936500793651 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(0.91893853320467 + N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] + N[(0.083333333333333 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -12.5 \lor \neg \left(z \leq 140\right):\\
\;\;\;\;\left(x \cdot \log x - x\right) + z \cdot \left(z \cdot \frac{0.0007936500793651}{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(0.91893853320467 + \left(\left(x + -0.5\right) \cdot \log x - x\right)\right) + \frac{0.083333333333333}{x}\\
\end{array}
\end{array}
if z < -12.5 or 140 < z Initial program 91.4%
sub-neg91.4%
metadata-eval91.4%
fma-def91.4%
fma-neg91.4%
metadata-eval91.4%
Simplified91.4%
Taylor expanded in x around inf 91.4%
sub-neg91.4%
mul-1-neg91.4%
log-rec91.4%
remove-double-neg91.4%
metadata-eval91.4%
distribute-rgt-in91.4%
*-rgt-identity91.4%
neg-mul-191.4%
*-rgt-identity91.4%
sub-neg91.4%
*-commutative91.4%
Simplified91.4%
Taylor expanded in y around 0 64.3%
fma-neg64.3%
metadata-eval64.3%
Simplified64.3%
Taylor expanded in z around inf 63.5%
*-commutative63.5%
associate-*l/63.5%
associate-*r/63.5%
metadata-eval63.5%
associate-*r/63.5%
unpow263.5%
associate-*l*65.5%
associate-*r/65.6%
metadata-eval65.6%
Simplified65.6%
if -12.5 < z < 140Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in z around 0 86.4%
Final simplification76.7%
(FPCore (x y z) :precision binary64 (if (or (<= z -1600.0) (not (<= z 5.4e+31))) (+ (- (* x (log x)) x) (* -0.0027777777777778 (/ z x))) (+ (/ 1.0 (* x 12.000000000000048)) (* x (+ (log x) -1.0)))))
double code(double x, double y, double z) {
double tmp;
if ((z <= -1600.0) || !(z <= 5.4e+31)) {
tmp = ((x * log(x)) - x) + (-0.0027777777777778 * (z / x));
} else {
tmp = (1.0 / (x * 12.000000000000048)) + (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 ((z <= (-1600.0d0)) .or. (.not. (z <= 5.4d+31))) then
tmp = ((x * log(x)) - x) + ((-0.0027777777777778d0) * (z / x))
else
tmp = (1.0d0 / (x * 12.000000000000048d0)) + (x * (log(x) + (-1.0d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if ((z <= -1600.0) || !(z <= 5.4e+31)) {
tmp = ((x * Math.log(x)) - x) + (-0.0027777777777778 * (z / x));
} else {
tmp = (1.0 / (x * 12.000000000000048)) + (x * (Math.log(x) + -1.0));
}
return tmp;
}
def code(x, y, z): tmp = 0 if (z <= -1600.0) or not (z <= 5.4e+31): tmp = ((x * math.log(x)) - x) + (-0.0027777777777778 * (z / x)) else: tmp = (1.0 / (x * 12.000000000000048)) + (x * (math.log(x) + -1.0)) return tmp
function code(x, y, z) tmp = 0.0 if ((z <= -1600.0) || !(z <= 5.4e+31)) tmp = Float64(Float64(Float64(x * log(x)) - x) + Float64(-0.0027777777777778 * Float64(z / x))); else tmp = Float64(Float64(1.0 / Float64(x * 12.000000000000048)) + Float64(x * Float64(log(x) + -1.0))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if ((z <= -1600.0) || ~((z <= 5.4e+31))) tmp = ((x * log(x)) - x) + (-0.0027777777777778 * (z / x)); else tmp = (1.0 / (x * 12.000000000000048)) + (x * (log(x) + -1.0)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[Or[LessEqual[z, -1600.0], N[Not[LessEqual[z, 5.4e+31]], $MachinePrecision]], N[(N[(N[(x * N[Log[x], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] + N[(-0.0027777777777778 * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[(x * 12.000000000000048), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1600 \lor \neg \left(z \leq 5.4 \cdot 10^{+31}\right):\\
\;\;\;\;\left(x \cdot \log x - x\right) + -0.0027777777777778 \cdot \frac{z}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{x \cdot 12.000000000000048} + x \cdot \left(\log x + -1\right)\\
\end{array}
\end{array}
if z < -1600 or 5.39999999999999971e31 < z Initial program 91.2%
sub-neg91.2%
metadata-eval91.2%
fma-def91.2%
fma-neg91.2%
metadata-eval91.2%
Simplified91.2%
Taylor expanded in x around inf 91.3%
sub-neg91.3%
mul-1-neg91.3%
log-rec91.3%
remove-double-neg91.3%
metadata-eval91.3%
distribute-rgt-in91.2%
*-rgt-identity91.2%
neg-mul-191.2%
*-rgt-identity91.2%
sub-neg91.2%
*-commutative91.2%
Simplified91.2%
Taylor expanded in z around 0 31.8%
*-commutative31.8%
Simplified31.8%
Taylor expanded in z around inf 33.2%
if -1600 < z < 5.39999999999999971e31Initial program 99.4%
sub-neg99.4%
metadata-eval99.4%
fma-def99.4%
fma-neg99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in z around 0 85.9%
Taylor expanded in x around inf 85.1%
sub-neg85.1%
mul-1-neg85.1%
log-rec85.1%
remove-double-neg85.1%
metadata-eval85.1%
Simplified85.1%
clear-num85.1%
inv-pow85.1%
div-inv85.2%
metadata-eval85.2%
Applied egg-rr85.2%
unpow-185.2%
Simplified85.2%
Final simplification61.4%
(FPCore (x y z) :precision binary64 (+ (/ 1.0 (* x 12.000000000000048)) (* x (+ (log x) -1.0))))
double code(double x, double y, double z) {
return (1.0 / (x * 12.000000000000048)) + (x * (log(x) + -1.0));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (1.0d0 / (x * 12.000000000000048d0)) + (x * (log(x) + (-1.0d0)))
end function
public static double code(double x, double y, double z) {
return (1.0 / (x * 12.000000000000048)) + (x * (Math.log(x) + -1.0));
}
def code(x, y, z): return (1.0 / (x * 12.000000000000048)) + (x * (math.log(x) + -1.0))
function code(x, y, z) return Float64(Float64(1.0 / Float64(x * 12.000000000000048)) + Float64(x * Float64(log(x) + -1.0))) end
function tmp = code(x, y, z) tmp = (1.0 / (x * 12.000000000000048)) + (x * (log(x) + -1.0)); end
code[x_, y_, z_] := N[(N[(1.0 / N[(x * 12.000000000000048), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{x \cdot 12.000000000000048} + x \cdot \left(\log x + -1\right)
\end{array}
Initial program 95.7%
sub-neg95.7%
metadata-eval95.7%
fma-def95.7%
fma-neg95.7%
metadata-eval95.7%
Simplified95.7%
Taylor expanded in z around 0 55.7%
Taylor expanded in x around inf 55.2%
sub-neg55.2%
mul-1-neg55.2%
log-rec55.2%
remove-double-neg55.2%
metadata-eval55.2%
Simplified55.2%
clear-num55.2%
inv-pow55.2%
div-inv55.2%
metadata-eval55.2%
Applied egg-rr55.2%
unpow-155.2%
Simplified55.2%
Final simplification55.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 95.7%
sub-neg95.7%
metadata-eval95.7%
fma-def95.7%
fma-neg95.7%
metadata-eval95.7%
Simplified95.7%
Taylor expanded in z around 0 55.7%
Taylor expanded in x around inf 55.2%
sub-neg55.2%
mul-1-neg55.2%
log-rec55.2%
remove-double-neg55.2%
metadata-eval55.2%
Simplified55.2%
add-sqr-sqrt55.1%
sqrt-unprod52.6%
frac-times52.6%
metadata-eval52.6%
Applied egg-rr52.6%
associate-/r*52.6%
Simplified52.6%
Taylor expanded in x around -inf 36.3%
Final simplification36.3%
(FPCore (x y z) :precision binary64 (+ (/ 0.083333333333333 x) (* x (+ (log x) -1.0))))
double code(double x, double y, double z) {
return (0.083333333333333 / x) + (x * (log(x) + -1.0));
}
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) + (x * (log(x) + (-1.0d0)))
end function
public static double code(double x, double y, double z) {
return (0.083333333333333 / x) + (x * (Math.log(x) + -1.0));
}
def code(x, y, z): return (0.083333333333333 / x) + (x * (math.log(x) + -1.0))
function code(x, y, z) return Float64(Float64(0.083333333333333 / x) + Float64(x * Float64(log(x) + -1.0))) end
function tmp = code(x, y, z) tmp = (0.083333333333333 / x) + (x * (log(x) + -1.0)); end
code[x_, y_, z_] := N[(N[(0.083333333333333 / x), $MachinePrecision] + N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{0.083333333333333}{x} + x \cdot \left(\log x + -1\right)
\end{array}
Initial program 95.7%
sub-neg95.7%
metadata-eval95.7%
fma-def95.7%
fma-neg95.7%
metadata-eval95.7%
Simplified95.7%
Taylor expanded in z around 0 55.7%
Taylor expanded in x around inf 55.2%
sub-neg55.2%
mul-1-neg55.2%
log-rec55.2%
remove-double-neg55.2%
metadata-eval55.2%
Simplified55.2%
Final simplification55.2%
(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 2023271
(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)))