
(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 10 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%
sub-neg99.8%
sub-neg99.8%
associate-+l+99.8%
associate-+l+99.8%
sub-neg99.8%
neg-sub099.8%
associate-+l-99.8%
neg-sub099.8%
neg-mul-199.8%
Simplified99.9%
Final simplification99.9%
(FPCore (x y z)
:precision binary64
(if (<= y 4.4e-274)
(- x z)
(if (<= y 2.9e-261)
(* (log y) -0.5)
(if (or (<= y 2.4e+104) (and (not (<= y 1.55e+134)) (<= y 2.6e+147)))
(- x z)
(* y (- 1.0 (log y)))))))
double code(double x, double y, double z) {
double tmp;
if (y <= 4.4e-274) {
tmp = x - z;
} else if (y <= 2.9e-261) {
tmp = log(y) * -0.5;
} else if ((y <= 2.4e+104) || (!(y <= 1.55e+134) && (y <= 2.6e+147))) {
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 <= 4.4d-274) then
tmp = x - z
else if (y <= 2.9d-261) then
tmp = log(y) * (-0.5d0)
else if ((y <= 2.4d+104) .or. (.not. (y <= 1.55d+134)) .and. (y <= 2.6d+147)) 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 <= 4.4e-274) {
tmp = x - z;
} else if (y <= 2.9e-261) {
tmp = Math.log(y) * -0.5;
} else if ((y <= 2.4e+104) || (!(y <= 1.55e+134) && (y <= 2.6e+147))) {
tmp = x - z;
} else {
tmp = y * (1.0 - Math.log(y));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 4.4e-274: tmp = x - z elif y <= 2.9e-261: tmp = math.log(y) * -0.5 elif (y <= 2.4e+104) or (not (y <= 1.55e+134) and (y <= 2.6e+147)): tmp = x - z else: tmp = y * (1.0 - math.log(y)) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 4.4e-274) tmp = Float64(x - z); elseif (y <= 2.9e-261) tmp = Float64(log(y) * -0.5); elseif ((y <= 2.4e+104) || (!(y <= 1.55e+134) && (y <= 2.6e+147))) 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 <= 4.4e-274) tmp = x - z; elseif (y <= 2.9e-261) tmp = log(y) * -0.5; elseif ((y <= 2.4e+104) || (~((y <= 1.55e+134)) && (y <= 2.6e+147))) tmp = x - z; else tmp = y * (1.0 - log(y)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 4.4e-274], N[(x - z), $MachinePrecision], If[LessEqual[y, 2.9e-261], N[(N[Log[y], $MachinePrecision] * -0.5), $MachinePrecision], If[Or[LessEqual[y, 2.4e+104], And[N[Not[LessEqual[y, 1.55e+134]], $MachinePrecision], LessEqual[y, 2.6e+147]]], 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 4.4 \cdot 10^{-274}:\\
\;\;\;\;x - z\\
\mathbf{elif}\;y \leq 2.9 \cdot 10^{-261}:\\
\;\;\;\;\log y \cdot -0.5\\
\mathbf{elif}\;y \leq 2.4 \cdot 10^{+104} \lor \neg \left(y \leq 1.55 \cdot 10^{+134}\right) \land y \leq 2.6 \cdot 10^{+147}:\\
\;\;\;\;x - z\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(1 - \log y\right)\\
\end{array}
\end{array}
if y < 4.3999999999999999e-274 or 2.89999999999999985e-261 < y < 2.4e104 or 1.54999999999999991e134 < y < 2.5999999999999999e147Initial program 99.9%
*-commutative99.9%
flip-+99.9%
associate-*r/99.9%
fma-neg99.9%
metadata-eval99.9%
metadata-eval99.9%
sub-neg99.9%
metadata-eval99.9%
Applied egg-rr99.9%
associate-/l*99.9%
associate-/r/99.9%
+-commutative99.9%
Simplified99.9%
div-inv99.9%
+-commutative99.9%
Applied egg-rr99.9%
Taylor expanded in x around inf 76.3%
if 4.3999999999999999e-274 < y < 2.89999999999999985e-261Initial program 100.0%
sub-neg100.0%
sub-neg100.0%
associate-+l+100.0%
associate-+l+100.0%
sub-neg100.0%
neg-sub0100.0%
associate-+l-100.0%
neg-sub0100.0%
neg-mul-1100.0%
Simplified100.0%
Taylor expanded in z around 0 84.9%
+-commutative84.9%
mul-1-neg84.9%
+-commutative84.9%
*-commutative84.9%
sub-neg84.9%
Simplified84.9%
Taylor expanded in x around 0 84.9%
Taylor expanded in y around 0 84.9%
*-commutative84.9%
Simplified84.9%
if 2.4e104 < y < 1.54999999999999991e134 or 2.5999999999999999e147 < y Initial program 99.6%
sub-neg99.6%
sub-neg99.6%
associate-+l+99.6%
associate-+l+99.6%
sub-neg99.6%
neg-sub099.6%
associate-+l-99.6%
neg-sub099.6%
neg-mul-199.6%
Simplified99.8%
Taylor expanded in z around 0 93.7%
+-commutative93.7%
mul-1-neg93.7%
+-commutative93.7%
*-commutative93.7%
sub-neg93.7%
Simplified93.7%
Taylor expanded in x around 0 82.2%
Taylor expanded in y around inf 82.2%
mul-1-neg82.2%
log-rec82.2%
distribute-rgt-neg-in82.2%
remove-double-neg82.2%
Simplified82.2%
Taylor expanded in y around 0 82.4%
Final simplification78.4%
(FPCore (x y z)
:precision binary64
(if (<= y 6.2e-274)
(- x z)
(if (<= y 2.9e-261)
(* (log y) -0.5)
(if (<= y 3.3e+49) (- x z) (- x (* y (+ (log y) -1.0)))))))
double code(double x, double y, double z) {
double tmp;
if (y <= 6.2e-274) {
tmp = x - z;
} else if (y <= 2.9e-261) {
tmp = log(y) * -0.5;
} else if (y <= 3.3e+49) {
tmp = x - z;
} else {
tmp = x - (y * (log(y) + -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 (y <= 6.2d-274) then
tmp = x - z
else if (y <= 2.9d-261) then
tmp = log(y) * (-0.5d0)
else if (y <= 3.3d+49) then
tmp = x - z
else
tmp = x - (y * (log(y) + (-1.0d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 6.2e-274) {
tmp = x - z;
} else if (y <= 2.9e-261) {
tmp = Math.log(y) * -0.5;
} else if (y <= 3.3e+49) {
tmp = x - z;
} else {
tmp = x - (y * (Math.log(y) + -1.0));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 6.2e-274: tmp = x - z elif y <= 2.9e-261: tmp = math.log(y) * -0.5 elif y <= 3.3e+49: tmp = x - z else: tmp = x - (y * (math.log(y) + -1.0)) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 6.2e-274) tmp = Float64(x - z); elseif (y <= 2.9e-261) tmp = Float64(log(y) * -0.5); elseif (y <= 3.3e+49) tmp = Float64(x - z); else tmp = Float64(x - Float64(y * Float64(log(y) + -1.0))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 6.2e-274) tmp = x - z; elseif (y <= 2.9e-261) tmp = log(y) * -0.5; elseif (y <= 3.3e+49) tmp = x - z; else tmp = x - (y * (log(y) + -1.0)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 6.2e-274], N[(x - z), $MachinePrecision], If[LessEqual[y, 2.9e-261], N[(N[Log[y], $MachinePrecision] * -0.5), $MachinePrecision], If[LessEqual[y, 3.3e+49], N[(x - z), $MachinePrecision], N[(x - N[(y * N[(N[Log[y], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 6.2 \cdot 10^{-274}:\\
\;\;\;\;x - z\\
\mathbf{elif}\;y \leq 2.9 \cdot 10^{-261}:\\
\;\;\;\;\log y \cdot -0.5\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+49}:\\
\;\;\;\;x - z\\
\mathbf{else}:\\
\;\;\;\;x - y \cdot \left(\log y + -1\right)\\
\end{array}
\end{array}
if y < 6.19999999999999956e-274 or 2.89999999999999985e-261 < y < 3.2999999999999998e49Initial program 100.0%
*-commutative100.0%
flip-+100.0%
associate-*r/100.0%
fma-neg100.0%
metadata-eval100.0%
metadata-eval100.0%
sub-neg100.0%
metadata-eval100.0%
Applied egg-rr100.0%
associate-/l*100.0%
associate-/r/100.0%
+-commutative100.0%
Simplified100.0%
div-inv100.0%
+-commutative100.0%
Applied egg-rr100.0%
Taylor expanded in x around inf 79.3%
if 6.19999999999999956e-274 < y < 2.89999999999999985e-261Initial program 100.0%
sub-neg100.0%
sub-neg100.0%
associate-+l+100.0%
associate-+l+100.0%
sub-neg100.0%
neg-sub0100.0%
associate-+l-100.0%
neg-sub0100.0%
neg-mul-1100.0%
Simplified100.0%
Taylor expanded in z around 0 84.9%
+-commutative84.9%
mul-1-neg84.9%
+-commutative84.9%
*-commutative84.9%
sub-neg84.9%
Simplified84.9%
Taylor expanded in x around 0 84.9%
Taylor expanded in y around 0 84.9%
*-commutative84.9%
Simplified84.9%
if 3.2999999999999998e49 < y Initial program 99.7%
sub-neg99.7%
sub-neg99.7%
associate-+l+99.7%
associate-+l+99.7%
sub-neg99.7%
neg-sub099.7%
associate-+l-99.7%
neg-sub099.7%
neg-mul-199.7%
Simplified99.8%
Taylor expanded in z around 0 88.6%
+-commutative88.6%
mul-1-neg88.6%
+-commutative88.6%
*-commutative88.6%
sub-neg88.6%
Simplified88.6%
Taylor expanded in y around 0 88.7%
*-commutative88.7%
cancel-sign-sub-inv88.7%
+-commutative88.7%
*-commutative88.7%
distribute-lft-out--88.6%
*-rgt-identity88.6%
sub-neg88.6%
neg-mul-188.6%
associate-+r+88.6%
log-rec88.6%
*-commutative88.6%
associate-+r+88.6%
neg-mul-188.6%
distribute-rgt-neg-in88.6%
log-rec88.6%
distribute-rgt-in88.6%
log-rec88.6%
Simplified88.6%
Taylor expanded in y around inf 88.7%
sub-neg88.7%
mul-1-neg88.7%
log-rec88.7%
remove-double-neg88.7%
metadata-eval88.7%
Simplified88.7%
Final simplification83.5%
(FPCore (x y z) :precision binary64 (if (<= y 5.8e-5) (- (- 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 <= 5.8e-5) {
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 <= 5.8d-5) 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 <= 5.8e-5) {
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 <= 5.8e-5: 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 <= 5.8e-5) 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 <= 5.8e-5) 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, 5.8e-5], 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 5.8 \cdot 10^{-5}:\\
\;\;\;\;\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 < 5.8e-5Initial program 100.0%
Taylor expanded in y around 0 100.0%
if 5.8e-5 < y Initial program 99.7%
sub-neg99.7%
sub-neg99.7%
associate-+l+99.7%
associate-+l+99.7%
sub-neg99.7%
neg-sub099.7%
associate-+l-99.7%
neg-sub099.7%
neg-mul-199.7%
Simplified99.8%
Taylor expanded in y around inf 99.5%
log-rec99.5%
sub-neg99.5%
Simplified99.5%
Final simplification99.8%
(FPCore (x y z) :precision binary64 (- (+ y (- x (* (log y) (+ y 0.5)))) z))
double code(double x, double y, double z) {
return (y + (x - (log(y) * (y + 0.5)))) - z;
}
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 - (log(y) * (y + 0.5d0)))) - z
end function
public static double code(double x, double y, double z) {
return (y + (x - (Math.log(y) * (y + 0.5)))) - z;
}
def code(x, y, z): return (y + (x - (math.log(y) * (y + 0.5)))) - z
function code(x, y, z) return Float64(Float64(y + Float64(x - Float64(log(y) * Float64(y + 0.5)))) - z) end
function tmp = code(x, y, z) tmp = (y + (x - (log(y) * (y + 0.5)))) - z; end
code[x_, y_, z_] := N[(N[(y + N[(x - N[(N[Log[y], $MachinePrecision] * N[(y + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]
\begin{array}{l}
\\
\left(y + \left(x - \log y \cdot \left(y + 0.5\right)\right)\right) - z
\end{array}
Initial program 99.8%
Final simplification99.8%
(FPCore (x y z) :precision binary64 (if (<= y 6.5e+50) (- (- x (* (log y) 0.5)) z) (- x (* y (+ (log y) -1.0)))))
double code(double x, double y, double z) {
double tmp;
if (y <= 6.5e+50) {
tmp = (x - (log(y) * 0.5)) - z;
} else {
tmp = x - (y * (log(y) + -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 (y <= 6.5d+50) then
tmp = (x - (log(y) * 0.5d0)) - z
else
tmp = x - (y * (log(y) + (-1.0d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 6.5e+50) {
tmp = (x - (Math.log(y) * 0.5)) - z;
} else {
tmp = x - (y * (Math.log(y) + -1.0));
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 6.5e+50: tmp = (x - (math.log(y) * 0.5)) - z else: tmp = x - (y * (math.log(y) + -1.0)) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 6.5e+50) tmp = Float64(Float64(x - Float64(log(y) * 0.5)) - z); else tmp = Float64(x - Float64(y * Float64(log(y) + -1.0))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 6.5e+50) tmp = (x - (log(y) * 0.5)) - z; else tmp = x - (y * (log(y) + -1.0)); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 6.5e+50], N[(N[(x - N[(N[Log[y], $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], N[(x - N[(y * N[(N[Log[y], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 6.5 \cdot 10^{+50}:\\
\;\;\;\;\left(x - \log y \cdot 0.5\right) - z\\
\mathbf{else}:\\
\;\;\;\;x - y \cdot \left(\log y + -1\right)\\
\end{array}
\end{array}
if y < 6.5000000000000003e50Initial program 100.0%
Taylor expanded in y around 0 98.1%
if 6.5000000000000003e50 < y Initial program 99.7%
sub-neg99.7%
sub-neg99.7%
associate-+l+99.7%
associate-+l+99.7%
sub-neg99.7%
neg-sub099.7%
associate-+l-99.7%
neg-sub099.7%
neg-mul-199.7%
Simplified99.8%
Taylor expanded in z around 0 88.6%
+-commutative88.6%
mul-1-neg88.6%
+-commutative88.6%
*-commutative88.6%
sub-neg88.6%
Simplified88.6%
Taylor expanded in y around 0 88.7%
*-commutative88.7%
cancel-sign-sub-inv88.7%
+-commutative88.7%
*-commutative88.7%
distribute-lft-out--88.6%
*-rgt-identity88.6%
sub-neg88.6%
neg-mul-188.6%
associate-+r+88.6%
log-rec88.6%
*-commutative88.6%
associate-+r+88.6%
neg-mul-188.6%
distribute-rgt-neg-in88.6%
log-rec88.6%
distribute-rgt-in88.6%
log-rec88.6%
Simplified88.6%
Taylor expanded in y around inf 88.7%
sub-neg88.7%
mul-1-neg88.7%
log-rec88.7%
remove-double-neg88.7%
metadata-eval88.7%
Simplified88.7%
Final simplification94.0%
(FPCore (x y z) :precision binary64 (if (<= y 6.2e-274) (- x z) (if (<= y 2.9e-261) (* (log y) -0.5) (- x z))))
double code(double x, double y, double z) {
double tmp;
if (y <= 6.2e-274) {
tmp = x - z;
} else if (y <= 2.9e-261) {
tmp = log(y) * -0.5;
} else {
tmp = x - z;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (y <= 6.2d-274) then
tmp = x - z
else if (y <= 2.9d-261) then
tmp = log(y) * (-0.5d0)
else
tmp = x - z
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 6.2e-274) {
tmp = x - z;
} else if (y <= 2.9e-261) {
tmp = Math.log(y) * -0.5;
} else {
tmp = x - z;
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 6.2e-274: tmp = x - z elif y <= 2.9e-261: tmp = math.log(y) * -0.5 else: tmp = x - z return tmp
function code(x, y, z) tmp = 0.0 if (y <= 6.2e-274) tmp = Float64(x - z); elseif (y <= 2.9e-261) tmp = Float64(log(y) * -0.5); else tmp = Float64(x - z); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 6.2e-274) tmp = x - z; elseif (y <= 2.9e-261) tmp = log(y) * -0.5; else tmp = x - z; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 6.2e-274], N[(x - z), $MachinePrecision], If[LessEqual[y, 2.9e-261], N[(N[Log[y], $MachinePrecision] * -0.5), $MachinePrecision], N[(x - z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 6.2 \cdot 10^{-274}:\\
\;\;\;\;x - z\\
\mathbf{elif}\;y \leq 2.9 \cdot 10^{-261}:\\
\;\;\;\;\log y \cdot -0.5\\
\mathbf{else}:\\
\;\;\;\;x - z\\
\end{array}
\end{array}
if y < 6.19999999999999956e-274 or 2.89999999999999985e-261 < y Initial program 99.8%
*-commutative99.8%
flip-+76.6%
associate-*r/76.6%
fma-neg76.6%
metadata-eval76.6%
metadata-eval76.6%
sub-neg76.6%
metadata-eval76.6%
Applied egg-rr76.6%
associate-/l*76.6%
associate-/r/76.6%
+-commutative76.6%
Simplified76.6%
div-inv76.6%
+-commutative76.6%
Applied egg-rr76.6%
Taylor expanded in x around inf 57.4%
if 6.19999999999999956e-274 < y < 2.89999999999999985e-261Initial program 100.0%
sub-neg100.0%
sub-neg100.0%
associate-+l+100.0%
associate-+l+100.0%
sub-neg100.0%
neg-sub0100.0%
associate-+l-100.0%
neg-sub0100.0%
neg-mul-1100.0%
Simplified100.0%
Taylor expanded in z around 0 84.9%
+-commutative84.9%
mul-1-neg84.9%
+-commutative84.9%
*-commutative84.9%
sub-neg84.9%
Simplified84.9%
Taylor expanded in x around 0 84.9%
Taylor expanded in y around 0 84.9%
*-commutative84.9%
Simplified84.9%
Final simplification58.1%
(FPCore (x y z) :precision binary64 (if (<= x -1.75e+50) x (if (<= x 6.6e+44) (- z) x)))
double code(double x, double y, double z) {
double tmp;
if (x <= -1.75e+50) {
tmp = x;
} else if (x <= 6.6e+44) {
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.75d+50)) then
tmp = x
else if (x <= 6.6d+44) 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.75e+50) {
tmp = x;
} else if (x <= 6.6e+44) {
tmp = -z;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1.75e+50: tmp = x elif x <= 6.6e+44: tmp = -z else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1.75e+50) tmp = x; elseif (x <= 6.6e+44) tmp = Float64(-z); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1.75e+50) tmp = x; elseif (x <= 6.6e+44) tmp = -z; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1.75e+50], x, If[LessEqual[x, 6.6e+44], (-z), x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.75 \cdot 10^{+50}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 6.6 \cdot 10^{+44}:\\
\;\;\;\;-z\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.75000000000000003e50 or 6.60000000000000027e44 < x Initial program 99.9%
sub-neg99.9%
sub-neg99.9%
associate-+l+99.9%
associate-+l+99.9%
sub-neg99.9%
neg-sub099.9%
associate-+l-99.9%
neg-sub099.9%
neg-mul-199.9%
Simplified99.9%
Taylor expanded in x around inf 68.2%
if -1.75000000000000003e50 < x < 6.60000000000000027e44Initial program 99.8%
Taylor expanded in y around inf 77.0%
*-commutative77.0%
log-rec77.0%
distribute-lft-neg-in77.0%
distribute-rgt-neg-in77.0%
Simplified77.0%
Taylor expanded in y around 0 38.7%
neg-mul-138.7%
Simplified38.7%
Final simplification50.8%
(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%
*-commutative99.8%
flip-+77.2%
associate-*r/77.2%
fma-neg77.2%
metadata-eval77.2%
metadata-eval77.2%
sub-neg77.2%
metadata-eval77.2%
Applied egg-rr77.2%
associate-/l*77.2%
associate-/r/77.2%
+-commutative77.2%
Simplified77.2%
div-inv77.2%
+-commutative77.2%
Applied egg-rr77.2%
Taylor expanded in x around inf 56.3%
Final simplification56.3%
(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%
sub-neg99.8%
sub-neg99.8%
associate-+l+99.8%
associate-+l+99.8%
sub-neg99.8%
neg-sub099.8%
associate-+l-99.8%
neg-sub099.8%
neg-mul-199.8%
Simplified99.9%
Taylor expanded in x around inf 30.7%
Final simplification30.7%
(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 2023240
(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))