
(FPCore (x y z) :precision binary64 (- (+ (- x (* (+ y 0.5) (log y))) y) z))
double code(double x, double y, double z) {
return ((x - ((y + 0.5) * log(y))) + y) - z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((x - ((y + 0.5d0) * log(y))) + y) - z
end function
public static double code(double x, double y, double z) {
return ((x - ((y + 0.5) * Math.log(y))) + y) - z;
}
def code(x, y, z): return ((x - ((y + 0.5) * math.log(y))) + y) - z
function code(x, y, z) return Float64(Float64(Float64(x - Float64(Float64(y + 0.5) * log(y))) + y) - z) end
function tmp = code(x, y, z) tmp = ((x - ((y + 0.5) * log(y))) + y) - z; end
code[x_, y_, z_] := N[(N[(N[(x - N[(N[(y + 0.5), $MachinePrecision] * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (- (+ (- x (* (+ y 0.5) (log y))) y) z))
double code(double x, double y, double z) {
return ((x - ((y + 0.5) * log(y))) + y) - z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((x - ((y + 0.5d0) * log(y))) + y) - z
end function
public static double code(double x, double y, double z) {
return ((x - ((y + 0.5) * Math.log(y))) + y) - z;
}
def code(x, y, z): return ((x - ((y + 0.5) * math.log(y))) + y) - z
function code(x, y, z) return Float64(Float64(Float64(x - Float64(Float64(y + 0.5) * log(y))) + y) - z) end
function tmp = code(x, y, z) tmp = ((x - ((y + 0.5) * log(y))) + y) - z; end
code[x_, y_, z_] := N[(N[(N[(x - N[(N[(y + 0.5), $MachinePrecision] * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z
\end{array}
(FPCore (x y z) :precision binary64 (- (+ (fma (- -0.5 y) (log y) y) x) z))
double code(double x, double y, double z) {
return (fma((-0.5 - y), log(y), y) + x) - z;
}
function code(x, y, z) return Float64(Float64(fma(Float64(-0.5 - y), log(y), y) + x) - z) end
code[x_, y_, z_] := N[(N[(N[(N[(-0.5 - y), $MachinePrecision] * N[Log[y], $MachinePrecision] + y), $MachinePrecision] + x), $MachinePrecision] - z), $MachinePrecision]
\begin{array}{l}
\\
\left(\mathsf{fma}\left(-0.5 - y, \log y, y\right) + x\right) - z
\end{array}
Initial program 99.8%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lower-+.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
lower--.f64N/A
metadata-eval99.8
Applied rewrites99.8%
Final simplification99.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (+ (* 1.0 x) y) z))
(t_1 (- (+ (- x (* (+ 0.5 y) (log y))) y) z)))
(if (<= t_1 -40000000000.0) t_0 (if (<= t_1 500.0) (* (log y) -0.5) t_0))))
double code(double x, double y, double z) {
double t_0 = ((1.0 * x) + y) - z;
double t_1 = ((x - ((0.5 + y) * log(y))) + y) - z;
double tmp;
if (t_1 <= -40000000000.0) {
tmp = t_0;
} else if (t_1 <= 500.0) {
tmp = log(y) * -0.5;
} else {
tmp = t_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) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ((1.0d0 * x) + y) - z
t_1 = ((x - ((0.5d0 + y) * log(y))) + y) - z
if (t_1 <= (-40000000000.0d0)) then
tmp = t_0
else if (t_1 <= 500.0d0) then
tmp = log(y) * (-0.5d0)
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = ((1.0 * x) + y) - z;
double t_1 = ((x - ((0.5 + y) * Math.log(y))) + y) - z;
double tmp;
if (t_1 <= -40000000000.0) {
tmp = t_0;
} else if (t_1 <= 500.0) {
tmp = Math.log(y) * -0.5;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = ((1.0 * x) + y) - z t_1 = ((x - ((0.5 + y) * math.log(y))) + y) - z tmp = 0 if t_1 <= -40000000000.0: tmp = t_0 elif t_1 <= 500.0: tmp = math.log(y) * -0.5 else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(Float64(Float64(1.0 * x) + y) - z) t_1 = Float64(Float64(Float64(x - Float64(Float64(0.5 + y) * log(y))) + y) - z) tmp = 0.0 if (t_1 <= -40000000000.0) tmp = t_0; elseif (t_1 <= 500.0) tmp = Float64(log(y) * -0.5); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = ((1.0 * x) + y) - z; t_1 = ((x - ((0.5 + y) * log(y))) + y) - z; tmp = 0.0; if (t_1 <= -40000000000.0) tmp = t_0; elseif (t_1 <= 500.0) tmp = log(y) * -0.5; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(1.0 * x), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(x - N[(N[(0.5 + y), $MachinePrecision] * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision]}, If[LessEqual[t$95$1, -40000000000.0], t$95$0, If[LessEqual[t$95$1, 500.0], N[(N[Log[y], $MachinePrecision] * -0.5), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(1 \cdot x + y\right) - z\\
t_1 := \left(\left(x - \left(0.5 + y\right) \cdot \log y\right) + y\right) - z\\
\mathbf{if}\;t\_1 \leq -40000000000:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq 500:\\
\;\;\;\;\log y \cdot -0.5\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (-.f64 (+.f64 (-.f64 x (*.f64 (+.f64 y #s(literal 1/2 binary64)) (log.f64 y))) y) z) < -4e10 or 500 < (-.f64 (+.f64 (-.f64 x (*.f64 (+.f64 y #s(literal 1/2 binary64)) (log.f64 y))) y) z) Initial program 99.8%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-neg-fracN/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f64N/A
lower-log.f6487.5
Applied rewrites87.5%
Taylor expanded in x around inf
Applied rewrites65.7%
if -4e10 < (-.f64 (+.f64 (-.f64 x (*.f64 (+.f64 y #s(literal 1/2 binary64)) (log.f64 y))) y) z) < 500Initial program 99.9%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around 0
lower--.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-+.f64N/A
lower-log.f6499.3
Applied rewrites99.3%
Taylor expanded in y around 0
Applied rewrites99.3%
Taylor expanded in z around 0
Applied rewrites97.2%
Final simplification69.0%
(FPCore (x y z) :precision binary64 (if (<= y 0.000225) (- (fma -0.5 (log y) x) z) (- (+ (fma (- y) (log y) y) x) z)))
double code(double x, double y, double z) {
double tmp;
if (y <= 0.000225) {
tmp = fma(-0.5, log(y), x) - z;
} else {
tmp = (fma(-y, log(y), y) + x) - z;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= 0.000225) tmp = Float64(fma(-0.5, log(y), x) - z); else tmp = Float64(Float64(fma(Float64(-y), log(y), y) + x) - z); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, 0.000225], N[(N[(-0.5 * N[Log[y], $MachinePrecision] + x), $MachinePrecision] - z), $MachinePrecision], N[(N[(N[((-y) * N[Log[y], $MachinePrecision] + y), $MachinePrecision] + x), $MachinePrecision] - z), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 0.000225:\\
\;\;\;\;\mathsf{fma}\left(-0.5, \log y, x\right) - z\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(-y, \log y, y\right) + x\right) - z\\
\end{array}
\end{array}
if y < 2.2499999999999999e-4Initial program 100.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-log.f64100.0
Applied rewrites100.0%
if 2.2499999999999999e-4 < y Initial program 99.7%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lower-+.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
lower--.f64N/A
metadata-eval99.7
Applied rewrites99.7%
Taylor expanded in y around inf
mul-1-negN/A
lower-neg.f6499.5
Applied rewrites99.5%
Final simplification99.8%
(FPCore (x y z) :precision binary64 (let* ((t_0 (- (+ (* 1.0 x) y) z))) (if (<= z -3800000000.0) t_0 (if (<= z 320.0) (fma -0.5 (log y) x) t_0))))
double code(double x, double y, double z) {
double t_0 = ((1.0 * x) + y) - z;
double tmp;
if (z <= -3800000000.0) {
tmp = t_0;
} else if (z <= 320.0) {
tmp = fma(-0.5, log(y), x);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(Float64(1.0 * x) + y) - z) tmp = 0.0 if (z <= -3800000000.0) tmp = t_0; elseif (z <= 320.0) tmp = fma(-0.5, log(y), x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(1.0 * x), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision]}, If[LessEqual[z, -3800000000.0], t$95$0, If[LessEqual[z, 320.0], N[(-0.5 * N[Log[y], $MachinePrecision] + x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(1 \cdot x + y\right) - z\\
\mathbf{if}\;z \leq -3800000000:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 320:\\
\;\;\;\;\mathsf{fma}\left(-0.5, \log y, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -3.8e9 or 320 < z Initial program 99.9%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-neg-fracN/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f64N/A
lower-log.f6490.9
Applied rewrites90.9%
Taylor expanded in x around inf
Applied rewrites78.9%
if -3.8e9 < z < 320Initial program 99.7%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
distribute-rgt-neg-inN/A
lift-+.f64N/A
flip-+N/A
div-invN/A
associate-*l*N/A
lower-fma.f64N/A
Applied rewrites76.4%
Taylor expanded in z around 0
associate-+r+N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
unpow2N/A
metadata-evalN/A
lower-fma.f64N/A
lower-log.f64N/A
lower--.f6475.9
Applied rewrites75.9%
Taylor expanded in y around 0
Applied rewrites61.8%
(FPCore (x y z) :precision binary64 (if (<= y 2.1e+50) (- (fma -0.5 (log y) x) z) (+ (fma (log y) (- -0.5 y) y) x)))
double code(double x, double y, double z) {
double tmp;
if (y <= 2.1e+50) {
tmp = fma(-0.5, log(y), x) - z;
} else {
tmp = fma(log(y), (-0.5 - y), y) + x;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= 2.1e+50) tmp = Float64(fma(-0.5, log(y), x) - z); else tmp = Float64(fma(log(y), Float64(-0.5 - y), y) + x); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, 2.1e+50], N[(N[(-0.5 * N[Log[y], $MachinePrecision] + x), $MachinePrecision] - z), $MachinePrecision], N[(N[(N[Log[y], $MachinePrecision] * N[(-0.5 - y), $MachinePrecision] + y), $MachinePrecision] + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.1 \cdot 10^{+50}:\\
\;\;\;\;\mathsf{fma}\left(-0.5, \log y, x\right) - z\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\log y, -0.5 - y, y\right) + x\\
\end{array}
\end{array}
if y < 2.1e50Initial program 100.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-log.f6498.8
Applied rewrites98.8%
if 2.1e50 < y Initial program 99.6%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
distribute-rgt-neg-inN/A
lift-+.f64N/A
flip-+N/A
div-invN/A
associate-*l*N/A
lower-fma.f64N/A
Applied rewrites48.4%
Taylor expanded in z around 0
associate-+r+N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
unpow2N/A
metadata-evalN/A
lower-fma.f64N/A
lower-log.f64N/A
lower--.f6438.6
Applied rewrites38.6%
Applied rewrites86.5%
Final simplification93.5%
(FPCore (x y z) :precision binary64 (if (<= y 2.1e+50) (- (fma -0.5 (log y) x) z) (+ (- y (* (log y) y)) x)))
double code(double x, double y, double z) {
double tmp;
if (y <= 2.1e+50) {
tmp = fma(-0.5, log(y), x) - z;
} else {
tmp = (y - (log(y) * y)) + x;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= 2.1e+50) tmp = Float64(fma(-0.5, log(y), x) - z); else tmp = Float64(Float64(y - Float64(log(y) * y)) + x); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, 2.1e+50], N[(N[(-0.5 * N[Log[y], $MachinePrecision] + x), $MachinePrecision] - z), $MachinePrecision], N[(N[(y - N[(N[Log[y], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.1 \cdot 10^{+50}:\\
\;\;\;\;\mathsf{fma}\left(-0.5, \log y, x\right) - z\\
\mathbf{else}:\\
\;\;\;\;\left(y - \log y \cdot y\right) + x\\
\end{array}
\end{array}
if y < 2.1e50Initial program 100.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-log.f6498.8
Applied rewrites98.8%
if 2.1e50 < y Initial program 99.6%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
distribute-rgt-neg-inN/A
lift-+.f64N/A
flip-+N/A
div-invN/A
associate-*l*N/A
lower-fma.f64N/A
Applied rewrites48.4%
Taylor expanded in z around 0
associate-+r+N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
unpow2N/A
metadata-evalN/A
lower-fma.f64N/A
lower-log.f64N/A
lower--.f6438.6
Applied rewrites38.6%
Taylor expanded in y around inf
Applied rewrites86.5%
Applied rewrites86.5%
Final simplification93.5%
(FPCore (x y z) :precision binary64 (if (<= y 7.2e+96) (- (fma -0.5 (log y) x) z) (- y (* (log y) y))))
double code(double x, double y, double z) {
double tmp;
if (y <= 7.2e+96) {
tmp = fma(-0.5, log(y), x) - z;
} else {
tmp = y - (log(y) * y);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= 7.2e+96) tmp = Float64(fma(-0.5, log(y), x) - z); else tmp = Float64(y - Float64(log(y) * y)); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, 7.2e+96], N[(N[(-0.5 * N[Log[y], $MachinePrecision] + x), $MachinePrecision] - z), $MachinePrecision], N[(y - N[(N[Log[y], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 7.2 \cdot 10^{+96}:\\
\;\;\;\;\mathsf{fma}\left(-0.5, \log y, x\right) - z\\
\mathbf{else}:\\
\;\;\;\;y - \log y \cdot y\\
\end{array}
\end{array}
if y < 7.20000000000000026e96Initial program 99.9%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-log.f6493.4
Applied rewrites93.4%
if 7.20000000000000026e96 < y Initial program 99.6%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.6
Applied rewrites99.6%
Taylor expanded in x around 0
lower--.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-+.f64N/A
lower-log.f6483.4
Applied rewrites83.4%
Taylor expanded in y around inf
Applied rewrites73.7%
(FPCore (x y z) :precision binary64 (if (<= y 1.05e+67) (- (+ (* 1.0 x) y) z) (- y (* (log y) y))))
double code(double x, double y, double z) {
double tmp;
if (y <= 1.05e+67) {
tmp = ((1.0 * x) + y) - z;
} else {
tmp = y - (log(y) * y);
}
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 (y <= 1.05d+67) then
tmp = ((1.0d0 * x) + y) - z
else
tmp = y - (log(y) * y)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 1.05e+67) {
tmp = ((1.0 * x) + y) - z;
} else {
tmp = y - (Math.log(y) * y);
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 1.05e+67: tmp = ((1.0 * x) + y) - z else: tmp = y - (math.log(y) * y) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 1.05e+67) tmp = Float64(Float64(Float64(1.0 * x) + y) - z); else tmp = Float64(y - Float64(log(y) * y)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 1.05e+67) tmp = ((1.0 * x) + y) - z; else tmp = y - (log(y) * y); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 1.05e+67], N[(N[(N[(1.0 * x), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision], N[(y - N[(N[Log[y], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.05 \cdot 10^{+67}:\\
\;\;\;\;\left(1 \cdot x + y\right) - z\\
\mathbf{else}:\\
\;\;\;\;y - \log y \cdot y\\
\end{array}
\end{array}
if y < 1.0500000000000001e67Initial program 99.9%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-neg-fracN/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f64N/A
lower-log.f6499.2
Applied rewrites99.2%
Taylor expanded in x around inf
Applied rewrites79.9%
if 1.0500000000000001e67 < y Initial program 99.6%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.6
Applied rewrites99.6%
Taylor expanded in x around 0
lower--.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-+.f64N/A
lower-log.f6483.0
Applied rewrites83.0%
Taylor expanded in y around inf
Applied rewrites70.5%
(FPCore (x y z) :precision binary64 (if (<= y 1.05e+67) (- (+ (* 1.0 x) y) z) (* (- 1.0 (log y)) y)))
double code(double x, double y, double z) {
double tmp;
if (y <= 1.05e+67) {
tmp = ((1.0 * x) + y) - z;
} else {
tmp = (1.0 - log(y)) * y;
}
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 (y <= 1.05d+67) then
tmp = ((1.0d0 * x) + y) - z
else
tmp = (1.0d0 - log(y)) * y
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 1.05e+67) {
tmp = ((1.0 * x) + y) - z;
} else {
tmp = (1.0 - Math.log(y)) * y;
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 1.05e+67: tmp = ((1.0 * x) + y) - z else: tmp = (1.0 - math.log(y)) * y return tmp
function code(x, y, z) tmp = 0.0 if (y <= 1.05e+67) tmp = Float64(Float64(Float64(1.0 * x) + y) - z); else tmp = Float64(Float64(1.0 - log(y)) * y); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 1.05e+67) tmp = ((1.0 * x) + y) - z; else tmp = (1.0 - log(y)) * y; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 1.05e+67], N[(N[(N[(1.0 * x), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision], N[(N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.05 \cdot 10^{+67}:\\
\;\;\;\;\left(1 \cdot x + y\right) - z\\
\mathbf{else}:\\
\;\;\;\;\left(1 - \log y\right) \cdot y\\
\end{array}
\end{array}
if y < 1.0500000000000001e67Initial program 99.9%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-neg-fracN/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f64N/A
lower-log.f6499.2
Applied rewrites99.2%
Taylor expanded in x around inf
Applied rewrites79.9%
if 1.0500000000000001e67 < y Initial program 99.6%
Taylor expanded in y around inf
*-commutativeN/A
mul-1-negN/A
log-recN/A
remove-double-negN/A
lower-*.f64N/A
lower--.f64N/A
lower-log.f6470.5
Applied rewrites70.5%
(FPCore (x y z) :precision binary64 (- (+ (* 1.0 x) y) z))
double code(double x, double y, double z) {
return ((1.0 * x) + y) - z;
}
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) + y) - z
end function
public static double code(double x, double y, double z) {
return ((1.0 * x) + y) - z;
}
def code(x, y, z): return ((1.0 * x) + y) - z
function code(x, y, z) return Float64(Float64(Float64(1.0 * x) + y) - z) end
function tmp = code(x, y, z) tmp = ((1.0 * x) + y) - z; end
code[x_, y_, z_] := N[(N[(N[(1.0 * x), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision]
\begin{array}{l}
\\
\left(1 \cdot x + y\right) - z
\end{array}
Initial program 99.8%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-neg-fracN/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f64N/A
lower-log.f6488.4
Applied rewrites88.4%
Taylor expanded in x around inf
Applied rewrites59.3%
(FPCore (x y z) :precision binary64 (- z))
double code(double x, double y, double z) {
return -z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = -z
end function
public static double code(double x, double y, double z) {
return -z;
}
def code(x, y, z): return -z
function code(x, y, z) return Float64(-z) end
function tmp = code(x, y, z) tmp = -z; end
code[x_, y_, z_] := (-z)
\begin{array}{l}
\\
-z
\end{array}
Initial program 99.8%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6429.8
Applied rewrites29.8%
(FPCore (x y z) :precision binary64 (- (- (+ y x) z) (* (+ y 0.5) (log y))))
double code(double x, double y, double z) {
return ((y + x) - z) - ((y + 0.5) * log(y));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = ((y + x) - z) - ((y + 0.5d0) * log(y))
end function
public static double code(double x, double y, double z) {
return ((y + x) - z) - ((y + 0.5) * Math.log(y));
}
def code(x, y, z): return ((y + x) - z) - ((y + 0.5) * math.log(y))
function code(x, y, z) return Float64(Float64(Float64(y + x) - z) - Float64(Float64(y + 0.5) * log(y))) end
function tmp = code(x, y, z) tmp = ((y + x) - z) - ((y + 0.5) * log(y)); end
code[x_, y_, z_] := N[(N[(N[(y + x), $MachinePrecision] - z), $MachinePrecision] - N[(N[(y + 0.5), $MachinePrecision] * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(y + x\right) - z\right) - \left(y + 0.5\right) \cdot \log y
\end{array}
herbie shell --seed 2024279
(FPCore (x y z)
:name "Numeric.SpecFunctions:stirlingError from math-functions-0.1.5.2"
:precision binary64
:alt
(! :herbie-platform default (- (- (+ y x) z) (* (+ y 1/2) (log y))))
(- (+ (- x (* (+ y 0.5) (log y))) y) z))