
(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 (+ x (- (fma (log y) (- -0.5 y) y) z)))
double code(double x, double y, double z) {
return x + (fma(log(y), (-0.5 - y), y) - z);
}
function code(x, y, z) return Float64(x + Float64(fma(log(y), Float64(-0.5 - y), y) - z)) end
code[x_, y_, z_] := N[(x + N[(N[(N[Log[y], $MachinePrecision] * N[(-0.5 - y), $MachinePrecision] + y), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\mathsf{fma}\left(\log y, -0.5 - y, y\right) - z\right)
\end{array}
Initial program 99.8%
associate--l+99.8%
sub-neg99.8%
associate-+l+99.8%
associate-+r-99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (x y z)
:precision binary64
(if (<= y 1.26e+62)
(- (+ x (* (log y) -0.5)) z)
(if (or (<= y 8.2e+130) (not (<= y 2.2e+188)))
(- (* y (- 1.0 (log y))) z)
(+ y (- x (* y (log y)))))))
double code(double x, double y, double z) {
double tmp;
if (y <= 1.26e+62) {
tmp = (x + (log(y) * -0.5)) - z;
} else if ((y <= 8.2e+130) || !(y <= 2.2e+188)) {
tmp = (y * (1.0 - log(y))) - z;
} else {
tmp = y + (x - (y * log(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.26d+62) then
tmp = (x + (log(y) * (-0.5d0))) - z
else if ((y <= 8.2d+130) .or. (.not. (y <= 2.2d+188))) then
tmp = (y * (1.0d0 - log(y))) - z
else
tmp = y + (x - (y * log(y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 1.26e+62) {
tmp = (x + (Math.log(y) * -0.5)) - z;
} else if ((y <= 8.2e+130) || !(y <= 2.2e+188)) {
tmp = (y * (1.0 - Math.log(y))) - z;
} else {
tmp = y + (x - (y * Math.log(y)));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 1.26e+62: tmp = (x + (math.log(y) * -0.5)) - z elif (y <= 8.2e+130) or not (y <= 2.2e+188): tmp = (y * (1.0 - math.log(y))) - z else: tmp = y + (x - (y * math.log(y))) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 1.26e+62) tmp = Float64(Float64(x + Float64(log(y) * -0.5)) - z); elseif ((y <= 8.2e+130) || !(y <= 2.2e+188)) tmp = Float64(Float64(y * Float64(1.0 - log(y))) - z); else tmp = Float64(y + Float64(x - Float64(y * log(y)))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 1.26e+62) tmp = (x + (log(y) * -0.5)) - z; elseif ((y <= 8.2e+130) || ~((y <= 2.2e+188))) tmp = (y * (1.0 - log(y))) - z; else tmp = y + (x - (y * log(y))); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 1.26e+62], N[(N[(x + N[(N[Log[y], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], If[Or[LessEqual[y, 8.2e+130], N[Not[LessEqual[y, 2.2e+188]], $MachinePrecision]], N[(N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], N[(y + N[(x - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.26 \cdot 10^{+62}:\\
\;\;\;\;\left(x + \log y \cdot -0.5\right) - z\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{+130} \lor \neg \left(y \leq 2.2 \cdot 10^{+188}\right):\\
\;\;\;\;y \cdot \left(1 - \log y\right) - z\\
\mathbf{else}:\\
\;\;\;\;y + \left(x - y \cdot \log y\right)\\
\end{array}
\end{array}
if y < 1.25999999999999995e62Initial program 100.0%
associate--l+100.0%
sub-neg100.0%
associate-+l+100.0%
associate-+r-100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
fma-def100.0%
+-commutative100.0%
distribute-neg-in100.0%
unsub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around 0 96.2%
+-commutative96.2%
Simplified96.2%
if 1.25999999999999995e62 < y < 8.19999999999999955e130 or 2.19999999999999999e188 < y Initial program 99.5%
associate--l+99.6%
Simplified99.6%
Taylor expanded in y around inf 89.6%
*-commutative89.6%
log-rec89.6%
distribute-lft-neg-in89.6%
distribute-rgt-neg-in89.6%
Simplified89.6%
Taylor expanded in y around 0 89.7%
+-commutative89.7%
mul-1-neg89.7%
unsub-neg89.7%
neg-mul-189.7%
sub-neg89.7%
Simplified89.7%
if 8.19999999999999955e130 < y < 2.19999999999999999e188Initial program 99.7%
associate--l+99.7%
sub-neg99.7%
associate-+l+99.7%
associate-+r-99.7%
*-commutative99.7%
distribute-rgt-neg-in99.7%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around 0 99.7%
associate-+r+99.7%
associate-*r*99.7%
neg-mul-199.7%
+-commutative99.7%
cancel-sign-sub-inv99.7%
associate--r+99.7%
+-commutative99.7%
+-commutative99.7%
+-commutative99.7%
associate--l+99.7%
+-commutative99.7%
+-commutative99.7%
fma-def99.7%
Simplified99.7%
Taylor expanded in y around inf 83.7%
mul-1-neg83.7%
log-rec83.7%
distribute-rgt-neg-in83.7%
remove-double-neg83.7%
Simplified83.7%
Final simplification92.6%
(FPCore (x y z)
:precision binary64
(if (<= y 5.2e-228)
(- x z)
(if (<= y 2.25e-212)
(- x (* (log y) 0.5))
(if (<= y 6.5e+15) (+ y (- x z)) (+ y (- x (* y (log y))))))))
double code(double x, double y, double z) {
double tmp;
if (y <= 5.2e-228) {
tmp = x - z;
} else if (y <= 2.25e-212) {
tmp = x - (log(y) * 0.5);
} else if (y <= 6.5e+15) {
tmp = y + (x - z);
} else {
tmp = y + (x - (y * log(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 <= 5.2d-228) then
tmp = x - z
else if (y <= 2.25d-212) then
tmp = x - (log(y) * 0.5d0)
else if (y <= 6.5d+15) then
tmp = y + (x - z)
else
tmp = y + (x - (y * log(y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 5.2e-228) {
tmp = x - z;
} else if (y <= 2.25e-212) {
tmp = x - (Math.log(y) * 0.5);
} else if (y <= 6.5e+15) {
tmp = y + (x - z);
} else {
tmp = y + (x - (y * Math.log(y)));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 5.2e-228: tmp = x - z elif y <= 2.25e-212: tmp = x - (math.log(y) * 0.5) elif y <= 6.5e+15: tmp = y + (x - z) else: tmp = y + (x - (y * math.log(y))) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 5.2e-228) tmp = Float64(x - z); elseif (y <= 2.25e-212) tmp = Float64(x - Float64(log(y) * 0.5)); elseif (y <= 6.5e+15) tmp = Float64(y + Float64(x - z)); else tmp = Float64(y + Float64(x - Float64(y * log(y)))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 5.2e-228) tmp = x - z; elseif (y <= 2.25e-212) tmp = x - (log(y) * 0.5); elseif (y <= 6.5e+15) tmp = y + (x - z); else tmp = y + (x - (y * log(y))); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 5.2e-228], N[(x - z), $MachinePrecision], If[LessEqual[y, 2.25e-212], N[(x - N[(N[Log[y], $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.5e+15], N[(y + N[(x - z), $MachinePrecision]), $MachinePrecision], N[(y + N[(x - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 5.2 \cdot 10^{-228}:\\
\;\;\;\;x - z\\
\mathbf{elif}\;y \leq 2.25 \cdot 10^{-212}:\\
\;\;\;\;x - \log y \cdot 0.5\\
\mathbf{elif}\;y \leq 6.5 \cdot 10^{+15}:\\
\;\;\;\;y + \left(x - z\right)\\
\mathbf{else}:\\
\;\;\;\;y + \left(x - y \cdot \log y\right)\\
\end{array}
\end{array}
if y < 5.2e-228Initial program 100.0%
associate--l+100.0%
sub-neg100.0%
associate-+l+100.0%
associate-+r-100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
fma-def100.0%
+-commutative100.0%
distribute-neg-in100.0%
unsub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 76.0%
log-rec76.0%
sub-neg76.0%
Simplified76.0%
Taylor expanded in y around 0 76.0%
if 5.2e-228 < y < 2.2499999999999999e-212Initial program 100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around 0 100.0%
Taylor expanded in y around 0 100.0%
if 2.2499999999999999e-212 < y < 6.5e15Initial program 100.0%
associate--l+100.0%
sub-neg100.0%
associate-+l+100.0%
associate-+r-100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
fma-def100.0%
+-commutative100.0%
distribute-neg-in100.0%
unsub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 100.0%
associate-+r+100.0%
associate-*r*100.0%
neg-mul-1100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
associate--r+100.0%
+-commutative100.0%
+-commutative100.0%
+-commutative100.0%
associate--l+100.0%
+-commutative100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in z around inf 75.6%
if 6.5e15 < y Initial program 99.6%
associate--l+99.6%
sub-neg99.6%
associate-+l+99.6%
associate-+r-99.6%
*-commutative99.6%
distribute-rgt-neg-in99.6%
fma-def99.8%
+-commutative99.8%
distribute-neg-in99.8%
unsub-neg99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in x around 0 99.6%
associate-+r+99.6%
associate-*r*99.6%
neg-mul-199.6%
+-commutative99.6%
cancel-sign-sub-inv99.6%
associate--r+99.6%
+-commutative99.6%
+-commutative99.6%
+-commutative99.6%
associate--l+99.6%
+-commutative99.6%
+-commutative99.6%
fma-def99.7%
Simplified99.7%
Taylor expanded in y around inf 77.7%
mul-1-neg77.7%
log-rec77.7%
distribute-rgt-neg-in77.7%
remove-double-neg77.7%
Simplified77.7%
Final simplification77.5%
(FPCore (x y z)
:precision binary64
(if (<= y 5.5e-228)
(- x z)
(if (<= y 6.6e-213)
(- x (* (log y) 0.5))
(if (<= y 4.2e+199) (- x z) (* y (- 1.0 (log y)))))))
double code(double x, double y, double z) {
double tmp;
if (y <= 5.5e-228) {
tmp = x - z;
} else if (y <= 6.6e-213) {
tmp = x - (log(y) * 0.5);
} else if (y <= 4.2e+199) {
tmp = x - z;
} else {
tmp = y * (1.0 - log(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 <= 5.5d-228) then
tmp = x - z
else if (y <= 6.6d-213) then
tmp = x - (log(y) * 0.5d0)
else if (y <= 4.2d+199) then
tmp = x - z
else
tmp = y * (1.0d0 - log(y))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 5.5e-228) {
tmp = x - z;
} else if (y <= 6.6e-213) {
tmp = x - (Math.log(y) * 0.5);
} else if (y <= 4.2e+199) {
tmp = x - z;
} else {
tmp = y * (1.0 - Math.log(y));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 5.5e-228: tmp = x - z elif y <= 6.6e-213: tmp = x - (math.log(y) * 0.5) elif y <= 4.2e+199: tmp = x - z else: tmp = y * (1.0 - math.log(y)) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 5.5e-228) tmp = Float64(x - z); elseif (y <= 6.6e-213) tmp = Float64(x - Float64(log(y) * 0.5)); elseif (y <= 4.2e+199) tmp = Float64(x - z); else tmp = Float64(y * Float64(1.0 - log(y))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 5.5e-228) tmp = x - z; elseif (y <= 6.6e-213) tmp = x - (log(y) * 0.5); elseif (y <= 4.2e+199) tmp = x - z; else tmp = y * (1.0 - log(y)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 5.5e-228], N[(x - z), $MachinePrecision], If[LessEqual[y, 6.6e-213], N[(x - N[(N[Log[y], $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.2e+199], N[(x - z), $MachinePrecision], N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 5.5 \cdot 10^{-228}:\\
\;\;\;\;x - z\\
\mathbf{elif}\;y \leq 6.6 \cdot 10^{-213}:\\
\;\;\;\;x - \log y \cdot 0.5\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{+199}:\\
\;\;\;\;x - z\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(1 - \log y\right)\\
\end{array}
\end{array}
if y < 5.49999999999999952e-228 or 6.60000000000000062e-213 < y < 4.1999999999999999e199Initial program 99.9%
associate--l+99.9%
sub-neg99.9%
associate-+l+99.9%
associate-+r-99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in y around inf 85.7%
log-rec85.7%
sub-neg85.7%
Simplified85.7%
Taylor expanded in y around 0 68.3%
if 5.49999999999999952e-228 < y < 6.60000000000000062e-213Initial program 100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in z around 0 100.0%
Taylor expanded in y around 0 100.0%
if 4.1999999999999999e199 < y Initial program 99.4%
associate--l+99.4%
sub-neg99.4%
associate-+l+99.4%
associate-+r-99.4%
*-commutative99.4%
distribute-rgt-neg-in99.4%
fma-def99.7%
+-commutative99.7%
distribute-neg-in99.7%
unsub-neg99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around 0 99.4%
associate-+r+99.4%
associate-*r*99.4%
neg-mul-199.4%
+-commutative99.4%
cancel-sign-sub-inv99.4%
associate--r+99.4%
+-commutative99.4%
+-commutative99.4%
+-commutative99.4%
associate--l+99.4%
+-commutative99.4%
+-commutative99.4%
fma-def99.5%
Simplified99.5%
Taylor expanded in y around inf 78.7%
log-rec78.7%
cancel-sign-sub-inv78.7%
metadata-eval78.7%
*-lft-identity78.7%
log-rec78.7%
log-rec78.7%
sub-neg78.7%
Simplified78.7%
Final simplification71.4%
(FPCore (x y z) :precision binary64 (if (<= x -1.08e+54) (- x z) (if (<= x 1.9e+94) (- (* y (- 1.0 (log y))) z) (+ y (- x (* y (log y)))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -1.08e+54) {
tmp = x - z;
} else if (x <= 1.9e+94) {
tmp = (y * (1.0 - log(y))) - z;
} else {
tmp = y + (x - (y * log(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 (x <= (-1.08d+54)) then
tmp = x - z
else if (x <= 1.9d+94) then
tmp = (y * (1.0d0 - log(y))) - z
else
tmp = y + (x - (y * log(y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -1.08e+54) {
tmp = x - z;
} else if (x <= 1.9e+94) {
tmp = (y * (1.0 - Math.log(y))) - z;
} else {
tmp = y + (x - (y * Math.log(y)));
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1.08e+54: tmp = x - z elif x <= 1.9e+94: tmp = (y * (1.0 - math.log(y))) - z else: tmp = y + (x - (y * math.log(y))) return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1.08e+54) tmp = Float64(x - z); elseif (x <= 1.9e+94) tmp = Float64(Float64(y * Float64(1.0 - log(y))) - z); else tmp = Float64(y + Float64(x - Float64(y * log(y)))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1.08e+54) tmp = x - z; elseif (x <= 1.9e+94) tmp = (y * (1.0 - log(y))) - z; else tmp = y + (x - (y * log(y))); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1.08e+54], N[(x - z), $MachinePrecision], If[LessEqual[x, 1.9e+94], N[(N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], N[(y + N[(x - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.08 \cdot 10^{+54}:\\
\;\;\;\;x - z\\
\mathbf{elif}\;x \leq 1.9 \cdot 10^{+94}:\\
\;\;\;\;y \cdot \left(1 - \log y\right) - z\\
\mathbf{else}:\\
\;\;\;\;y + \left(x - y \cdot \log y\right)\\
\end{array}
\end{array}
if x < -1.08000000000000008e54Initial program 99.8%
associate--l+99.8%
sub-neg99.8%
associate-+l+99.8%
associate-+r-99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in y around inf 99.9%
log-rec99.9%
sub-neg99.9%
Simplified99.9%
Taylor expanded in y around 0 86.3%
if -1.08000000000000008e54 < x < 1.8999999999999998e94Initial program 99.8%
associate--l+99.8%
Simplified99.8%
Taylor expanded in y around inf 75.0%
*-commutative75.0%
log-rec75.0%
distribute-lft-neg-in75.0%
distribute-rgt-neg-in75.0%
Simplified75.0%
Taylor expanded in y around 0 75.1%
+-commutative75.1%
mul-1-neg75.1%
unsub-neg75.1%
neg-mul-175.1%
sub-neg75.1%
Simplified75.1%
if 1.8999999999999998e94 < x Initial program 99.9%
associate--l+99.9%
sub-neg99.9%
associate-+l+99.9%
associate-+r-99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around 0 99.9%
associate-+r+99.9%
associate-*r*99.9%
neg-mul-199.9%
+-commutative99.9%
cancel-sign-sub-inv99.9%
associate--r+99.9%
+-commutative99.9%
+-commutative99.9%
+-commutative99.9%
associate--l+99.9%
+-commutative99.9%
+-commutative99.9%
fma-def99.9%
Simplified99.9%
Taylor expanded in y around inf 95.4%
mul-1-neg95.4%
log-rec95.4%
distribute-rgt-neg-in95.4%
remove-double-neg95.4%
Simplified95.4%
Final simplification80.8%
(FPCore (x y z) :precision binary64 (if (<= y 1.35e-18) (- (+ x (* (log y) -0.5)) z) (+ x (- (* y (- 1.0 (log y))) z))))
double code(double x, double y, double z) {
double tmp;
if (y <= 1.35e-18) {
tmp = (x + (log(y) * -0.5)) - z;
} else {
tmp = x + ((y * (1.0 - log(y))) - z);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (y <= 1.35d-18) then
tmp = (x + (log(y) * (-0.5d0))) - z
else
tmp = x + ((y * (1.0d0 - log(y))) - z)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 1.35e-18) {
tmp = (x + (Math.log(y) * -0.5)) - z;
} else {
tmp = x + ((y * (1.0 - Math.log(y))) - z);
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 1.35e-18: tmp = (x + (math.log(y) * -0.5)) - z else: tmp = x + ((y * (1.0 - math.log(y))) - z) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 1.35e-18) tmp = Float64(Float64(x + Float64(log(y) * -0.5)) - z); else tmp = Float64(x + Float64(Float64(y * Float64(1.0 - log(y))) - z)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 1.35e-18) tmp = (x + (log(y) * -0.5)) - z; else tmp = x + ((y * (1.0 - log(y))) - z); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 1.35e-18], N[(N[(x + N[(N[Log[y], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], N[(x + N[(N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.35 \cdot 10^{-18}:\\
\;\;\;\;\left(x + \log y \cdot -0.5\right) - z\\
\mathbf{else}:\\
\;\;\;\;x + \left(y \cdot \left(1 - \log y\right) - z\right)\\
\end{array}
\end{array}
if y < 1.34999999999999994e-18Initial program 100.0%
associate--l+100.0%
sub-neg100.0%
associate-+l+100.0%
associate-+r-100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
fma-def100.0%
+-commutative100.0%
distribute-neg-in100.0%
unsub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
+-commutative100.0%
Simplified100.0%
if 1.34999999999999994e-18 < y Initial program 99.6%
associate--l+99.7%
sub-neg99.7%
associate-+l+99.7%
associate-+r-99.6%
*-commutative99.6%
distribute-rgt-neg-in99.6%
fma-def99.8%
+-commutative99.8%
distribute-neg-in99.8%
unsub-neg99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in y around inf 99.4%
log-rec99.4%
sub-neg99.4%
Simplified99.4%
Final simplification99.7%
(FPCore (x y z) :precision binary64 (+ (- x (* (log y) (+ y 0.5))) (- y z)))
double code(double x, double y, double z) {
return (x - (log(y) * (y + 0.5))) + (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 - (log(y) * (y + 0.5d0))) + (y - z)
end function
public static double code(double x, double y, double z) {
return (x - (Math.log(y) * (y + 0.5))) + (y - z);
}
def code(x, y, z): return (x - (math.log(y) * (y + 0.5))) + (y - z)
function code(x, y, z) return Float64(Float64(x - Float64(log(y) * Float64(y + 0.5))) + Float64(y - z)) end
function tmp = code(x, y, z) tmp = (x - (log(y) * (y + 0.5))) + (y - z); end
code[x_, y_, z_] := N[(N[(x - N[(N[Log[y], $MachinePrecision] * N[(y + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y - z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \log y \cdot \left(y + 0.5\right)\right) + \left(y - z\right)
\end{array}
Initial program 99.8%
associate--l+99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x y z) :precision binary64 (if (<= y 3.5e+199) (- x z) (* y (- 1.0 (log y)))))
double code(double x, double y, double z) {
double tmp;
if (y <= 3.5e+199) {
tmp = x - z;
} else {
tmp = y * (1.0 - log(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 <= 3.5d+199) then
tmp = x - z
else
tmp = y * (1.0d0 - log(y))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 3.5e+199) {
tmp = x - z;
} else {
tmp = y * (1.0 - Math.log(y));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 3.5e+199: tmp = x - z else: tmp = y * (1.0 - math.log(y)) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 3.5e+199) tmp = Float64(x - z); else tmp = Float64(y * Float64(1.0 - log(y))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 3.5e+199) tmp = x - z; else tmp = y * (1.0 - log(y)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 3.5e+199], N[(x - z), $MachinePrecision], N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.5 \cdot 10^{+199}:\\
\;\;\;\;x - z\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(1 - \log y\right)\\
\end{array}
\end{array}
if y < 3.49999999999999981e199Initial program 99.9%
associate--l+99.9%
sub-neg99.9%
associate-+l+99.9%
associate-+r-99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in y around inf 84.1%
log-rec84.1%
sub-neg84.1%
Simplified84.1%
Taylor expanded in y around 0 67.4%
if 3.49999999999999981e199 < y Initial program 99.4%
associate--l+99.4%
sub-neg99.4%
associate-+l+99.4%
associate-+r-99.4%
*-commutative99.4%
distribute-rgt-neg-in99.4%
fma-def99.7%
+-commutative99.7%
distribute-neg-in99.7%
unsub-neg99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in x around 0 99.4%
associate-+r+99.4%
associate-*r*99.4%
neg-mul-199.4%
+-commutative99.4%
cancel-sign-sub-inv99.4%
associate--r+99.4%
+-commutative99.4%
+-commutative99.4%
+-commutative99.4%
associate--l+99.4%
+-commutative99.4%
+-commutative99.4%
fma-def99.5%
Simplified99.5%
Taylor expanded in y around inf 78.7%
log-rec78.7%
cancel-sign-sub-inv78.7%
metadata-eval78.7%
*-lft-identity78.7%
log-rec78.7%
log-rec78.7%
sub-neg78.7%
Simplified78.7%
Final simplification69.7%
(FPCore (x y z) :precision binary64 (if (<= x -1.4e+72) x (if (<= x 6.5e+94) (- z) x)))
double code(double x, double y, double z) {
double tmp;
if (x <= -1.4e+72) {
tmp = x;
} else if (x <= 6.5e+94) {
tmp = -z;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-1.4d+72)) then
tmp = x
else if (x <= 6.5d+94) then
tmp = -z
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -1.4e+72) {
tmp = x;
} else if (x <= 6.5e+94) {
tmp = -z;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1.4e+72: tmp = x elif x <= 6.5e+94: tmp = -z else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1.4e+72) tmp = x; elseif (x <= 6.5e+94) tmp = Float64(-z); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1.4e+72) tmp = x; elseif (x <= 6.5e+94) tmp = -z; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1.4e+72], x, If[LessEqual[x, 6.5e+94], (-z), x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.4 \cdot 10^{+72}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 6.5 \cdot 10^{+94}:\\
\;\;\;\;-z\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.4e72 or 6.49999999999999976e94 < x Initial program 99.8%
associate--l+99.9%
sub-neg99.9%
associate-+l+99.9%
associate-+r-99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around inf 71.2%
if -1.4e72 < x < 6.49999999999999976e94Initial program 99.8%
associate--l+99.8%
sub-neg99.8%
associate-+l+99.8%
associate-+r-99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around 0 99.8%
associate-+r+99.8%
associate-*r*99.8%
neg-mul-199.8%
+-commutative99.8%
cancel-sign-sub-inv99.8%
associate--r+99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
associate--l+99.8%
+-commutative99.8%
+-commutative99.8%
fma-def99.8%
Simplified99.8%
Taylor expanded in z around inf 39.1%
neg-mul-139.1%
Simplified39.1%
Final simplification50.0%
(FPCore (x y z) :precision binary64 (- x z))
double code(double x, double y, double z) {
return x - 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 - z
end function
public static double code(double x, double y, double z) {
return x - z;
}
def code(x, y, z): return x - z
function code(x, y, z) return Float64(x - z) end
function tmp = code(x, y, z) tmp = x - z; end
code[x_, y_, z_] := N[(x - z), $MachinePrecision]
\begin{array}{l}
\\
x - z
\end{array}
Initial program 99.8%
associate--l+99.8%
sub-neg99.8%
associate-+l+99.8%
associate-+r-99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in y around inf 87.2%
log-rec87.2%
sub-neg87.2%
Simplified87.2%
Taylor expanded in y around 0 58.0%
Final simplification58.0%
(FPCore (x y z) :precision binary64 x)
double code(double x, double y, double z) {
return 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
end function
public static double code(double x, double y, double z) {
return x;
}
def code(x, y, z): return x
function code(x, y, z) return x end
function tmp = code(x, y, z) tmp = x; end
code[x_, y_, z_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 99.8%
associate--l+99.8%
sub-neg99.8%
associate-+l+99.8%
associate-+r-99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
fma-def99.9%
+-commutative99.9%
distribute-neg-in99.9%
unsub-neg99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around inf 29.1%
Final simplification29.1%
(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 2023334
(FPCore (x y z)
:name "Numeric.SpecFunctions:stirlingError from math-functions-0.1.5.2"
:precision binary64
:herbie-target
(- (- (+ y x) z) (* (+ y 0.5) (log y)))
(- (+ (- x (* (+ y 0.5) (log y))) y) z))