
(FPCore (x y z) :precision binary64 (+ x (/ y (- (* 1.1283791670955126 (exp z)) (* x y)))))
double code(double x, double y, double z) {
return x + (y / ((1.1283791670955126 * exp(z)) - (x * y)));
}
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 / ((1.1283791670955126d0 * exp(z)) - (x * y)))
end function
public static double code(double x, double y, double z) {
return x + (y / ((1.1283791670955126 * Math.exp(z)) - (x * y)));
}
def code(x, y, z): return x + (y / ((1.1283791670955126 * math.exp(z)) - (x * y)))
function code(x, y, z) return Float64(x + Float64(y / Float64(Float64(1.1283791670955126 * exp(z)) - Float64(x * y)))) end
function tmp = code(x, y, z) tmp = x + (y / ((1.1283791670955126 * exp(z)) - (x * y))); end
code[x_, y_, z_] := N[(x + N[(y / N[(N[(1.1283791670955126 * N[Exp[z], $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (+ x (/ y (- (* 1.1283791670955126 (exp z)) (* x y)))))
double code(double x, double y, double z) {
return x + (y / ((1.1283791670955126 * exp(z)) - (x * y)));
}
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 / ((1.1283791670955126d0 * exp(z)) - (x * y)))
end function
public static double code(double x, double y, double z) {
return x + (y / ((1.1283791670955126 * Math.exp(z)) - (x * y)));
}
def code(x, y, z): return x + (y / ((1.1283791670955126 * math.exp(z)) - (x * y)))
function code(x, y, z) return Float64(x + Float64(y / Float64(Float64(1.1283791670955126 * exp(z)) - Float64(x * y)))) end
function tmp = code(x, y, z) tmp = x + (y / ((1.1283791670955126 * exp(z)) - (x * y))); end
code[x_, y_, z_] := N[(x + N[(y / N[(N[(1.1283791670955126 * N[Exp[z], $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}
\end{array}
(FPCore (x y z) :precision binary64 (+ x (/ -1.0 (fma (exp z) (pow (* y -0.8862269254527579) -1.0) x))))
double code(double x, double y, double z) {
return x + (-1.0 / fma(exp(z), pow((y * -0.8862269254527579), -1.0), x));
}
function code(x, y, z) return Float64(x + Float64(-1.0 / fma(exp(z), (Float64(y * -0.8862269254527579) ^ -1.0), x))) end
code[x_, y_, z_] := N[(x + N[(-1.0 / N[(N[Exp[z], $MachinePrecision] * N[Power[N[(y * -0.8862269254527579), $MachinePrecision], -1.0], $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{-1}{\mathsf{fma}\left(e^{z}, {\left(y \cdot -0.8862269254527579\right)}^{-1}, x\right)}
\end{array}
Initial program 95.7%
remove-double-neg95.7%
neg-mul-195.7%
associate-/l*95.7%
neg-mul-195.7%
associate-/r*95.7%
div-sub95.8%
metadata-eval95.8%
associate-/l*95.8%
*-commutative95.8%
neg-mul-195.8%
distribute-lft-neg-out95.8%
/-rgt-identity95.8%
div-sub95.8%
associate-/r*95.8%
neg-mul-195.8%
*-rgt-identity95.8%
times-frac95.8%
/-rgt-identity95.8%
*-commutative95.8%
associate-*r/99.9%
Simplified99.9%
clear-num99.9%
inv-pow99.9%
div-inv99.9%
metadata-eval99.9%
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (x y z)
:precision binary64
(if (<= (exp z) 0.0)
(- x (/ 1.0 x))
(if (<= (exp z) 1.0)
(+ x (/ y (- (+ 1.1283791670955126 (* z 1.1283791670955126)) (* x y))))
x)))
double code(double x, double y, double z) {
double tmp;
if (exp(z) <= 0.0) {
tmp = x - (1.0 / x);
} else if (exp(z) <= 1.0) {
tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y)));
} 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 (exp(z) <= 0.0d0) then
tmp = x - (1.0d0 / x)
else if (exp(z) <= 1.0d0) then
tmp = x + (y / ((1.1283791670955126d0 + (z * 1.1283791670955126d0)) - (x * y)))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (Math.exp(z) <= 0.0) {
tmp = x - (1.0 / x);
} else if (Math.exp(z) <= 1.0) {
tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y)));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if math.exp(z) <= 0.0: tmp = x - (1.0 / x) elif math.exp(z) <= 1.0: tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y))) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (exp(z) <= 0.0) tmp = Float64(x - Float64(1.0 / x)); elseif (exp(z) <= 1.0) tmp = Float64(x + Float64(y / Float64(Float64(1.1283791670955126 + Float64(z * 1.1283791670955126)) - Float64(x * y)))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (exp(z) <= 0.0) tmp = x - (1.0 / x); elseif (exp(z) <= 1.0) tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y))); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[N[Exp[z], $MachinePrecision], 0.0], N[(x - N[(1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Exp[z], $MachinePrecision], 1.0], N[(x + N[(y / N[(N[(1.1283791670955126 + N[(z * 1.1283791670955126), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{z} \leq 0:\\
\;\;\;\;x - \frac{1}{x}\\
\mathbf{elif}\;e^{z} \leq 1:\\
\;\;\;\;x + \frac{y}{\left(1.1283791670955126 + z \cdot 1.1283791670955126\right) - x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if (exp.f64 z) < 0.0Initial program 88.2%
remove-double-neg88.2%
neg-mul-188.2%
associate-/l*88.3%
neg-mul-188.3%
associate-/r*88.3%
div-sub88.7%
metadata-eval88.7%
associate-/l*88.7%
*-commutative88.7%
neg-mul-188.7%
distribute-lft-neg-out88.7%
/-rgt-identity88.7%
div-sub88.6%
associate-/r*88.6%
neg-mul-188.6%
*-rgt-identity88.6%
times-frac88.6%
/-rgt-identity88.6%
*-commutative88.6%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 0.0 < (exp.f64 z) < 1Initial program 99.8%
Taylor expanded in z around 0 99.8%
if 1 < (exp.f64 z) Initial program 96.6%
remove-double-neg96.6%
neg-mul-196.6%
associate-/l*96.6%
neg-mul-196.6%
associate-/r*96.6%
div-sub96.6%
metadata-eval96.6%
associate-/l*96.6%
*-commutative96.6%
neg-mul-196.6%
distribute-lft-neg-out96.6%
/-rgt-identity96.6%
div-sub96.6%
associate-/r*96.6%
neg-mul-196.6%
*-rgt-identity96.6%
times-frac96.6%
/-rgt-identity96.6%
*-commutative96.6%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification99.9%
(FPCore (x y z) :precision binary64 (if (<= (exp z) 0.0) (- x (/ 1.0 x)) (+ x (/ y (- (* (exp z) 1.1283791670955126) (* x y))))))
double code(double x, double y, double z) {
double tmp;
if (exp(z) <= 0.0) {
tmp = x - (1.0 / x);
} else {
tmp = x + (y / ((exp(z) * 1.1283791670955126) - (x * 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 (exp(z) <= 0.0d0) then
tmp = x - (1.0d0 / x)
else
tmp = x + (y / ((exp(z) * 1.1283791670955126d0) - (x * y)))
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (Math.exp(z) <= 0.0) {
tmp = x - (1.0 / x);
} else {
tmp = x + (y / ((Math.exp(z) * 1.1283791670955126) - (x * y)));
}
return tmp;
}
def code(x, y, z): tmp = 0 if math.exp(z) <= 0.0: tmp = x - (1.0 / x) else: tmp = x + (y / ((math.exp(z) * 1.1283791670955126) - (x * y))) return tmp
function code(x, y, z) tmp = 0.0 if (exp(z) <= 0.0) tmp = Float64(x - Float64(1.0 / x)); else tmp = Float64(x + Float64(y / Float64(Float64(exp(z) * 1.1283791670955126) - Float64(x * y)))); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (exp(z) <= 0.0) tmp = x - (1.0 / x); else tmp = x + (y / ((exp(z) * 1.1283791670955126) - (x * y))); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[N[Exp[z], $MachinePrecision], 0.0], N[(x - N[(1.0 / x), $MachinePrecision]), $MachinePrecision], N[(x + N[(y / N[(N[(N[Exp[z], $MachinePrecision] * 1.1283791670955126), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{z} \leq 0:\\
\;\;\;\;x - \frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y}{e^{z} \cdot 1.1283791670955126 - x \cdot y}\\
\end{array}
\end{array}
if (exp.f64 z) < 0.0Initial program 88.2%
remove-double-neg88.2%
neg-mul-188.2%
associate-/l*88.3%
neg-mul-188.3%
associate-/r*88.3%
div-sub88.7%
metadata-eval88.7%
associate-/l*88.7%
*-commutative88.7%
neg-mul-188.7%
distribute-lft-neg-out88.7%
/-rgt-identity88.7%
div-sub88.6%
associate-/r*88.6%
neg-mul-188.6%
*-rgt-identity88.6%
times-frac88.6%
/-rgt-identity88.6%
*-commutative88.6%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 0.0 < (exp.f64 z) Initial program 98.8%
Final simplification99.1%
(FPCore (x y z) :precision binary64 (+ x (/ -1.0 (fma -1.1283791670955126 (/ (exp z) y) x))))
double code(double x, double y, double z) {
return x + (-1.0 / fma(-1.1283791670955126, (exp(z) / y), x));
}
function code(x, y, z) return Float64(x + Float64(-1.0 / fma(-1.1283791670955126, Float64(exp(z) / y), x))) end
code[x_, y_, z_] := N[(x + N[(-1.0 / N[(-1.1283791670955126 * N[(N[Exp[z], $MachinePrecision] / y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{-1}{\mathsf{fma}\left(-1.1283791670955126, \frac{e^{z}}{y}, x\right)}
\end{array}
Initial program 95.7%
remove-double-neg95.7%
neg-mul-195.7%
associate-/l*95.7%
neg-mul-195.7%
associate-/r*95.7%
div-sub95.8%
metadata-eval95.8%
associate-/l*95.8%
*-commutative95.8%
neg-mul-195.8%
distribute-lft-neg-out95.8%
/-rgt-identity95.8%
div-sub95.8%
associate-/r*95.8%
neg-mul-195.8%
*-rgt-identity95.8%
times-frac95.8%
/-rgt-identity95.8%
*-commutative95.8%
associate-*r/99.9%
Simplified99.9%
clear-num99.9%
inv-pow99.9%
div-inv99.9%
metadata-eval99.9%
Applied egg-rr99.9%
Taylor expanded in z around inf 99.9%
+-commutative99.9%
fma-def99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (x y z) :precision binary64 (+ x (/ -1.0 (fma (exp z) (/ -1.1283791670955126 y) x))))
double code(double x, double y, double z) {
return x + (-1.0 / fma(exp(z), (-1.1283791670955126 / y), x));
}
function code(x, y, z) return Float64(x + Float64(-1.0 / fma(exp(z), Float64(-1.1283791670955126 / y), x))) end
code[x_, y_, z_] := N[(x + N[(-1.0 / N[(N[Exp[z], $MachinePrecision] * N[(-1.1283791670955126 / y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{-1}{\mathsf{fma}\left(e^{z}, \frac{-1.1283791670955126}{y}, x\right)}
\end{array}
Initial program 95.7%
remove-double-neg95.7%
neg-mul-195.7%
associate-/l*95.7%
neg-mul-195.7%
associate-/r*95.7%
div-sub95.8%
metadata-eval95.8%
associate-/l*95.8%
*-commutative95.8%
neg-mul-195.8%
distribute-lft-neg-out95.8%
/-rgt-identity95.8%
div-sub95.8%
associate-/r*95.8%
neg-mul-195.8%
*-rgt-identity95.8%
times-frac95.8%
/-rgt-identity95.8%
*-commutative95.8%
associate-*r/99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (x y z) :precision binary64 (if (<= z -310.0) (- x (/ 1.0 x)) (if (<= z 3.1e-32) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -310.0) {
tmp = x - (1.0 / x);
} else if (z <= 3.1e-32) {
tmp = x + (y / (1.1283791670955126 - (x * y)));
} 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 (z <= (-310.0d0)) then
tmp = x - (1.0d0 / x)
else if (z <= 3.1d-32) then
tmp = x + (y / (1.1283791670955126d0 - (x * y)))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -310.0) {
tmp = x - (1.0 / x);
} else if (z <= 3.1e-32) {
tmp = x + (y / (1.1283791670955126 - (x * y)));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -310.0: tmp = x - (1.0 / x) elif z <= 3.1e-32: tmp = x + (y / (1.1283791670955126 - (x * y))) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -310.0) tmp = Float64(x - Float64(1.0 / x)); elseif (z <= 3.1e-32) tmp = Float64(x + Float64(y / Float64(1.1283791670955126 - Float64(x * y)))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -310.0) tmp = x - (1.0 / x); elseif (z <= 3.1e-32) tmp = x + (y / (1.1283791670955126 - (x * y))); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -310.0], N[(x - N[(1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.1e-32], N[(x + N[(y / N[(1.1283791670955126 - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -310:\\
\;\;\;\;x - \frac{1}{x}\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{-32}:\\
\;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -310Initial program 88.2%
remove-double-neg88.2%
neg-mul-188.2%
associate-/l*88.3%
neg-mul-188.3%
associate-/r*88.3%
div-sub88.7%
metadata-eval88.7%
associate-/l*88.7%
*-commutative88.7%
neg-mul-188.7%
distribute-lft-neg-out88.7%
/-rgt-identity88.7%
div-sub88.6%
associate-/r*88.6%
neg-mul-188.6%
*-rgt-identity88.6%
times-frac88.6%
/-rgt-identity88.6%
*-commutative88.6%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if -310 < z < 3.10000000000000011e-32Initial program 99.8%
Taylor expanded in z around 0 99.5%
if 3.10000000000000011e-32 < z Initial program 96.8%
remove-double-neg96.8%
neg-mul-196.8%
associate-/l*96.8%
neg-mul-196.8%
associate-/r*96.8%
div-sub96.8%
metadata-eval96.8%
associate-/l*96.8%
*-commutative96.8%
neg-mul-196.8%
distribute-lft-neg-out96.8%
/-rgt-identity96.8%
div-sub96.8%
associate-/r*96.8%
neg-mul-196.8%
*-rgt-identity96.8%
times-frac96.8%
/-rgt-identity96.8%
*-commutative96.8%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification99.8%
(FPCore (x y z) :precision binary64 (if (<= z -7.2e+111) x (if (<= z 3.1e-32) (+ x (* y 0.8862269254527579)) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -7.2e+111) {
tmp = x;
} else if (z <= 3.1e-32) {
tmp = x + (y * 0.8862269254527579);
} 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 (z <= (-7.2d+111)) then
tmp = x
else if (z <= 3.1d-32) then
tmp = x + (y * 0.8862269254527579d0)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -7.2e+111) {
tmp = x;
} else if (z <= 3.1e-32) {
tmp = x + (y * 0.8862269254527579);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -7.2e+111: tmp = x elif z <= 3.1e-32: tmp = x + (y * 0.8862269254527579) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -7.2e+111) tmp = x; elseif (z <= 3.1e-32) tmp = Float64(x + Float64(y * 0.8862269254527579)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -7.2e+111) tmp = x; elseif (z <= 3.1e-32) tmp = x + (y * 0.8862269254527579); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -7.2e+111], x, If[LessEqual[z, 3.1e-32], N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.2 \cdot 10^{+111}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{-32}:\\
\;\;\;\;x + y \cdot 0.8862269254527579\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -7.2000000000000004e111 or 3.10000000000000011e-32 < z Initial program 92.2%
remove-double-neg92.2%
neg-mul-192.2%
associate-/l*92.3%
neg-mul-192.3%
associate-/r*92.3%
div-sub92.5%
metadata-eval92.5%
associate-/l*92.5%
*-commutative92.5%
neg-mul-192.5%
distribute-lft-neg-out92.5%
/-rgt-identity92.5%
div-sub92.4%
associate-/r*92.4%
neg-mul-192.4%
*-rgt-identity92.4%
times-frac92.4%
/-rgt-identity92.4%
*-commutative92.4%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 75.1%
if -7.2000000000000004e111 < z < 3.10000000000000011e-32Initial program 98.4%
Taylor expanded in z around 0 94.5%
Taylor expanded in y around 0 77.3%
*-commutative77.3%
Simplified77.3%
Final simplification76.3%
(FPCore (x y z) :precision binary64 (if (<= z -0.0195) (- x (/ 1.0 x)) (if (<= z 2.85e-32) (+ x (* y 0.8862269254527579)) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -0.0195) {
tmp = x - (1.0 / x);
} else if (z <= 2.85e-32) {
tmp = x + (y * 0.8862269254527579);
} 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 (z <= (-0.0195d0)) then
tmp = x - (1.0d0 / x)
else if (z <= 2.85d-32) then
tmp = x + (y * 0.8862269254527579d0)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -0.0195) {
tmp = x - (1.0 / x);
} else if (z <= 2.85e-32) {
tmp = x + (y * 0.8862269254527579);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -0.0195: tmp = x - (1.0 / x) elif z <= 2.85e-32: tmp = x + (y * 0.8862269254527579) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -0.0195) tmp = Float64(x - Float64(1.0 / x)); elseif (z <= 2.85e-32) tmp = Float64(x + Float64(y * 0.8862269254527579)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -0.0195) tmp = x - (1.0 / x); elseif (z <= 2.85e-32) tmp = x + (y * 0.8862269254527579); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -0.0195], N[(x - N[(1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.85e-32], N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -0.0195:\\
\;\;\;\;x - \frac{1}{x}\\
\mathbf{elif}\;z \leq 2.85 \cdot 10^{-32}:\\
\;\;\;\;x + y \cdot 0.8862269254527579\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -0.0195Initial program 88.2%
remove-double-neg88.2%
neg-mul-188.2%
associate-/l*88.3%
neg-mul-188.3%
associate-/r*88.3%
div-sub88.7%
metadata-eval88.7%
associate-/l*88.7%
*-commutative88.7%
neg-mul-188.7%
distribute-lft-neg-out88.7%
/-rgt-identity88.7%
div-sub88.6%
associate-/r*88.6%
neg-mul-188.6%
*-rgt-identity88.6%
times-frac88.6%
/-rgt-identity88.6%
*-commutative88.6%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if -0.0195 < z < 2.8500000000000002e-32Initial program 99.8%
Taylor expanded in z around 0 99.5%
Taylor expanded in y around 0 82.6%
*-commutative82.6%
Simplified82.6%
if 2.8500000000000002e-32 < z Initial program 96.8%
remove-double-neg96.8%
neg-mul-196.8%
associate-/l*96.8%
neg-mul-196.8%
associate-/r*96.8%
div-sub96.8%
metadata-eval96.8%
associate-/l*96.8%
*-commutative96.8%
neg-mul-196.8%
distribute-lft-neg-out96.8%
/-rgt-identity96.8%
div-sub96.8%
associate-/r*96.8%
neg-mul-196.8%
*-rgt-identity96.8%
times-frac96.8%
/-rgt-identity96.8%
*-commutative96.8%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification92.0%
(FPCore (x y z) :precision binary64 (if (<= x -3.3e-245) x (if (<= x 3.9e-156) (* y 0.8862269254527579) x)))
double code(double x, double y, double z) {
double tmp;
if (x <= -3.3e-245) {
tmp = x;
} else if (x <= 3.9e-156) {
tmp = y * 0.8862269254527579;
} 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 <= (-3.3d-245)) then
tmp = x
else if (x <= 3.9d-156) then
tmp = y * 0.8862269254527579d0
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -3.3e-245) {
tmp = x;
} else if (x <= 3.9e-156) {
tmp = y * 0.8862269254527579;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -3.3e-245: tmp = x elif x <= 3.9e-156: tmp = y * 0.8862269254527579 else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (x <= -3.3e-245) tmp = x; elseif (x <= 3.9e-156) tmp = Float64(y * 0.8862269254527579); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -3.3e-245) tmp = x; elseif (x <= 3.9e-156) tmp = y * 0.8862269254527579; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -3.3e-245], x, If[LessEqual[x, 3.9e-156], N[(y * 0.8862269254527579), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.3 \cdot 10^{-245}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 3.9 \cdot 10^{-156}:\\
\;\;\;\;y \cdot 0.8862269254527579\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -3.3000000000000001e-245 or 3.9000000000000001e-156 < x Initial program 96.6%
remove-double-neg96.6%
neg-mul-196.6%
associate-/l*96.6%
neg-mul-196.6%
associate-/r*96.6%
div-sub96.7%
metadata-eval96.7%
associate-/l*96.7%
*-commutative96.7%
neg-mul-196.7%
distribute-lft-neg-out96.7%
/-rgt-identity96.7%
div-sub96.6%
associate-/r*96.6%
neg-mul-196.6%
*-rgt-identity96.6%
times-frac96.6%
/-rgt-identity96.6%
*-commutative96.6%
associate-*r/100.0%
Simplified100.0%
Taylor expanded in x around inf 79.6%
if -3.3000000000000001e-245 < x < 3.9000000000000001e-156Initial program 92.0%
Taylor expanded in z around 0 60.6%
Taylor expanded in y around 0 53.2%
*-commutative53.2%
Simplified53.2%
Taylor expanded in x around 0 48.9%
Final simplification73.5%
(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 95.7%
remove-double-neg95.7%
neg-mul-195.7%
associate-/l*95.7%
neg-mul-195.7%
associate-/r*95.7%
div-sub95.8%
metadata-eval95.8%
associate-/l*95.8%
*-commutative95.8%
neg-mul-195.8%
distribute-lft-neg-out95.8%
/-rgt-identity95.8%
div-sub95.8%
associate-/r*95.8%
neg-mul-195.8%
*-rgt-identity95.8%
times-frac95.8%
/-rgt-identity95.8%
*-commutative95.8%
associate-*r/99.9%
Simplified99.9%
Taylor expanded in x around inf 69.2%
Final simplification69.2%
(FPCore (x y z) :precision binary64 (+ x (/ 1.0 (- (* (/ 1.1283791670955126 y) (exp z)) x))))
double code(double x, double y, double z) {
return x + (1.0 / (((1.1283791670955126 / y) * exp(z)) - 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 + (1.0d0 / (((1.1283791670955126d0 / y) * exp(z)) - x))
end function
public static double code(double x, double y, double z) {
return x + (1.0 / (((1.1283791670955126 / y) * Math.exp(z)) - x));
}
def code(x, y, z): return x + (1.0 / (((1.1283791670955126 / y) * math.exp(z)) - x))
function code(x, y, z) return Float64(x + Float64(1.0 / Float64(Float64(Float64(1.1283791670955126 / y) * exp(z)) - x))) end
function tmp = code(x, y, z) tmp = x + (1.0 / (((1.1283791670955126 / y) * exp(z)) - x)); end
code[x_, y_, z_] := N[(x + N[(1.0 / N[(N[(N[(1.1283791670955126 / y), $MachinePrecision] * N[Exp[z], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{1}{\frac{1.1283791670955126}{y} \cdot e^{z} - x}
\end{array}
herbie shell --seed 2023293
(FPCore (x y z)
:name "Numeric.SpecFunctions:invErfc from math-functions-0.1.5.2, A"
:precision binary64
:herbie-target
(+ x (/ 1.0 (- (* (/ 1.1283791670955126 y) (exp z)) x)))
(+ x (/ y (- (* 1.1283791670955126 (exp z)) (* x y)))))