
(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 11 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) (/ -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.3%
remove-double-neg95.3%
neg-mul-195.3%
associate-/l*95.3%
neg-mul-195.3%
associate-/r*95.3%
div-sub95.4%
metadata-eval95.4%
associate-/l*95.4%
*-commutative95.4%
associate-*l*95.4%
neg-mul-195.4%
/-rgt-identity95.4%
div-sub95.3%
Simplified99.9%
Final simplification99.9%
(FPCore (x y z)
:precision binary64
(if (<= (exp z) 0.0)
(+ x (/ -1.0 x))
(if (<= (exp z) 1.2)
(+ x (/ y (- (+ 1.1283791670955126 (* z 1.1283791670955126)) (* x y))))
(+ x (/ (* y 0.8862269254527579) (exp z))))))
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.2) {
tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y)));
} else {
tmp = x + ((y * 0.8862269254527579) / exp(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 (exp(z) <= 0.0d0) then
tmp = x + ((-1.0d0) / x)
else if (exp(z) <= 1.2d0) then
tmp = x + (y / ((1.1283791670955126d0 + (z * 1.1283791670955126d0)) - (x * y)))
else
tmp = x + ((y * 0.8862269254527579d0) / exp(z))
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.2) {
tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y)));
} else {
tmp = x + ((y * 0.8862269254527579) / Math.exp(z));
}
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.2: tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y))) else: tmp = x + ((y * 0.8862269254527579) / math.exp(z)) 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.2) tmp = Float64(x + Float64(y / Float64(Float64(1.1283791670955126 + Float64(z * 1.1283791670955126)) - Float64(x * y)))); else tmp = Float64(x + Float64(Float64(y * 0.8862269254527579) / exp(z))); 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.2) tmp = x + (y / ((1.1283791670955126 + (z * 1.1283791670955126)) - (x * y))); else tmp = x + ((y * 0.8862269254527579) / exp(z)); 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.2], N[(x + N[(y / N[(N[(1.1283791670955126 + N[(z * 1.1283791670955126), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y * 0.8862269254527579), $MachinePrecision] / N[Exp[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{z} \leq 0:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;e^{z} \leq 1.2:\\
\;\;\;\;x + \frac{y}{\left(1.1283791670955126 + z \cdot 1.1283791670955126\right) - x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{y \cdot 0.8862269254527579}{e^{z}}\\
\end{array}
\end{array}
if (exp.f64 z) < 0.0Initial program 88.4%
remove-double-neg88.4%
neg-mul-188.4%
associate-/l*88.5%
neg-mul-188.5%
associate-/r*88.5%
div-sub88.8%
metadata-eval88.8%
associate-/l*88.8%
*-commutative88.8%
associate-*l*88.8%
neg-mul-188.8%
/-rgt-identity88.8%
div-sub88.6%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 0.0 < (exp.f64 z) < 1.19999999999999996Initial program 99.8%
Taylor expanded in z around 0 99.8%
if 1.19999999999999996 < (exp.f64 z) Initial program 92.6%
remove-double-neg92.6%
neg-mul-192.6%
associate-/l*92.6%
neg-mul-192.6%
associate-/r*92.6%
div-sub92.6%
metadata-eval92.6%
associate-/l*92.6%
*-commutative92.6%
associate-*l*92.6%
neg-mul-192.6%
/-rgt-identity92.6%
div-sub92.6%
Simplified100.0%
Taylor expanded in y around 0 100.0%
associate-*r/100.0%
Simplified100.0%
Final simplification99.9%
(FPCore (x y z)
:precision binary64
(if (<= (exp z) 0.0)
(+ x (/ -1.0 x))
(if (<= (exp z) 2.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) <= 2.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) <= 2.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) <= 2.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) <= 2.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) <= 2.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) <= 2.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], 2.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 2:\\
\;\;\;\;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.4%
remove-double-neg88.4%
neg-mul-188.4%
associate-/l*88.5%
neg-mul-188.5%
associate-/r*88.5%
div-sub88.8%
metadata-eval88.8%
associate-/l*88.8%
*-commutative88.8%
associate-*l*88.8%
neg-mul-188.8%
/-rgt-identity88.8%
div-sub88.6%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 0.0 < (exp.f64 z) < 2Initial program 99.8%
Taylor expanded in z around 0 99.3%
if 2 < (exp.f64 z) Initial program 92.3%
remove-double-neg92.3%
neg-mul-192.3%
associate-/l*92.3%
neg-mul-192.3%
associate-/r*92.3%
div-sub92.3%
metadata-eval92.3%
associate-/l*92.3%
*-commutative92.3%
associate-*l*92.3%
neg-mul-192.3%
/-rgt-identity92.3%
div-sub92.3%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification99.6%
(FPCore (x y z) :precision binary64 (+ x (/ 1.0 (- (* 1.1283791670955126 (/ (exp z) y)) x))))
double code(double x, double y, double z) {
return x + (1.0 / ((1.1283791670955126 * (exp(z) / y)) - 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 * (exp(z) / y)) - x))
end function
public static double code(double x, double y, double z) {
return x + (1.0 / ((1.1283791670955126 * (Math.exp(z) / y)) - x));
}
def code(x, y, z): return x + (1.0 / ((1.1283791670955126 * (math.exp(z) / y)) - x))
function code(x, y, z) return Float64(x + Float64(1.0 / Float64(Float64(1.1283791670955126 * Float64(exp(z) / y)) - x))) end
function tmp = code(x, y, z) tmp = x + (1.0 / ((1.1283791670955126 * (exp(z) / y)) - x)); end
code[x_, y_, z_] := N[(x + N[(1.0 / N[(N[(1.1283791670955126 * N[(N[Exp[z], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{1}{1.1283791670955126 \cdot \frac{e^{z}}{y} - x}
\end{array}
Initial program 95.3%
*-lft-identity95.3%
associate-/l*95.3%
remove-double-neg95.3%
neg-mul-195.3%
associate-/r*95.3%
div-sub95.4%
metadata-eval95.4%
associate-/l*95.4%
*-commutative95.4%
associate-*l*95.4%
neg-mul-195.4%
/-rgt-identity95.4%
div-sub95.3%
associate-/r*95.3%
neg-mul-195.3%
remove-double-neg95.3%
associate-*r/95.3%
distribute-lft-neg-out95.3%
neg-mul-195.3%
*-commutative95.3%
Simplified99.9%
Final simplification99.9%
(FPCore (x y z)
:precision binary64
(if (<= x -1e-10)
x
(if (<= x -7.8e-218)
(/ -1.0 x)
(if (<= x -1.15e-271)
(* y 0.8862269254527579)
(if (<= x -1.12e-294)
(/ -1.0 x)
(if (<= x 7e-294)
x
(if (<= x 3.8e-167)
(* y 0.8862269254527579)
(if (<= x 1.16e-126) (/ -1.0 x) x))))))))
double code(double x, double y, double z) {
double tmp;
if (x <= -1e-10) {
tmp = x;
} else if (x <= -7.8e-218) {
tmp = -1.0 / x;
} else if (x <= -1.15e-271) {
tmp = y * 0.8862269254527579;
} else if (x <= -1.12e-294) {
tmp = -1.0 / x;
} else if (x <= 7e-294) {
tmp = x;
} else if (x <= 3.8e-167) {
tmp = y * 0.8862269254527579;
} else if (x <= 1.16e-126) {
tmp = -1.0 / x;
} 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 <= (-1d-10)) then
tmp = x
else if (x <= (-7.8d-218)) then
tmp = (-1.0d0) / x
else if (x <= (-1.15d-271)) then
tmp = y * 0.8862269254527579d0
else if (x <= (-1.12d-294)) then
tmp = (-1.0d0) / x
else if (x <= 7d-294) then
tmp = x
else if (x <= 3.8d-167) then
tmp = y * 0.8862269254527579d0
else if (x <= 1.16d-126) then
tmp = (-1.0d0) / x
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -1e-10) {
tmp = x;
} else if (x <= -7.8e-218) {
tmp = -1.0 / x;
} else if (x <= -1.15e-271) {
tmp = y * 0.8862269254527579;
} else if (x <= -1.12e-294) {
tmp = -1.0 / x;
} else if (x <= 7e-294) {
tmp = x;
} else if (x <= 3.8e-167) {
tmp = y * 0.8862269254527579;
} else if (x <= 1.16e-126) {
tmp = -1.0 / x;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1e-10: tmp = x elif x <= -7.8e-218: tmp = -1.0 / x elif x <= -1.15e-271: tmp = y * 0.8862269254527579 elif x <= -1.12e-294: tmp = -1.0 / x elif x <= 7e-294: tmp = x elif x <= 3.8e-167: tmp = y * 0.8862269254527579 elif x <= 1.16e-126: tmp = -1.0 / x else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1e-10) tmp = x; elseif (x <= -7.8e-218) tmp = Float64(-1.0 / x); elseif (x <= -1.15e-271) tmp = Float64(y * 0.8862269254527579); elseif (x <= -1.12e-294) tmp = Float64(-1.0 / x); elseif (x <= 7e-294) tmp = x; elseif (x <= 3.8e-167) tmp = Float64(y * 0.8862269254527579); elseif (x <= 1.16e-126) tmp = Float64(-1.0 / x); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1e-10) tmp = x; elseif (x <= -7.8e-218) tmp = -1.0 / x; elseif (x <= -1.15e-271) tmp = y * 0.8862269254527579; elseif (x <= -1.12e-294) tmp = -1.0 / x; elseif (x <= 7e-294) tmp = x; elseif (x <= 3.8e-167) tmp = y * 0.8862269254527579; elseif (x <= 1.16e-126) tmp = -1.0 / x; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1e-10], x, If[LessEqual[x, -7.8e-218], N[(-1.0 / x), $MachinePrecision], If[LessEqual[x, -1.15e-271], N[(y * 0.8862269254527579), $MachinePrecision], If[LessEqual[x, -1.12e-294], N[(-1.0 / x), $MachinePrecision], If[LessEqual[x, 7e-294], x, If[LessEqual[x, 3.8e-167], N[(y * 0.8862269254527579), $MachinePrecision], If[LessEqual[x, 1.16e-126], N[(-1.0 / x), $MachinePrecision], x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1 \cdot 10^{-10}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq -7.8 \cdot 10^{-218}:\\
\;\;\;\;\frac{-1}{x}\\
\mathbf{elif}\;x \leq -1.15 \cdot 10^{-271}:\\
\;\;\;\;y \cdot 0.8862269254527579\\
\mathbf{elif}\;x \leq -1.12 \cdot 10^{-294}:\\
\;\;\;\;\frac{-1}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-294}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{-167}:\\
\;\;\;\;y \cdot 0.8862269254527579\\
\mathbf{elif}\;x \leq 1.16 \cdot 10^{-126}:\\
\;\;\;\;\frac{-1}{x}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.00000000000000004e-10 or -1.12e-294 < x < 7.00000000000000064e-294 or 1.16e-126 < x Initial program 97.6%
remove-double-neg97.6%
neg-mul-197.6%
associate-/l*97.6%
neg-mul-197.6%
associate-/r*97.6%
div-sub97.6%
metadata-eval97.6%
associate-/l*97.6%
*-commutative97.6%
associate-*l*97.6%
neg-mul-197.6%
/-rgt-identity97.6%
div-sub97.6%
Simplified100.0%
Taylor expanded in x around inf 89.9%
if -1.00000000000000004e-10 < x < -7.8e-218 or -1.15000000000000004e-271 < x < -1.12e-294 or 3.79999999999999967e-167 < x < 1.16e-126Initial program 88.3%
remove-double-neg88.3%
neg-mul-188.3%
associate-/l*88.5%
neg-mul-188.5%
associate-/r*88.5%
div-sub88.7%
metadata-eval88.7%
associate-/l*88.7%
*-commutative88.7%
associate-*l*88.7%
neg-mul-188.7%
/-rgt-identity88.7%
div-sub88.5%
Simplified99.8%
Taylor expanded in x around inf 67.1%
Taylor expanded in x around 0 67.1%
if -7.8e-218 < x < -1.15000000000000004e-271 or 7.00000000000000064e-294 < x < 3.79999999999999967e-167Initial program 93.4%
remove-double-neg93.4%
neg-mul-193.4%
associate-/l*93.2%
neg-mul-193.2%
associate-/r*93.2%
div-sub93.6%
metadata-eval93.6%
associate-/l*93.6%
*-commutative93.6%
associate-*l*93.6%
neg-mul-193.6%
/-rgt-identity93.6%
div-sub93.4%
Simplified99.6%
Taylor expanded in z around 0 80.2%
Taylor expanded in x around 0 68.1%
*-commutative68.1%
Simplified68.1%
Taylor expanded in x around 0 55.8%
*-commutative55.8%
Simplified55.8%
Final simplification81.2%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (+ x (/ -1.0 x))) (t_1 (+ x (/ y 1.1283791670955126))))
(if (<= z -3.8e-38)
t_0
(if (<= z 2.7e-204)
t_1
(if (<= z 1.25e-162) t_0 (if (<= z 8.5e-42) t_1 x))))))
double code(double x, double y, double z) {
double t_0 = x + (-1.0 / x);
double t_1 = x + (y / 1.1283791670955126);
double tmp;
if (z <= -3.8e-38) {
tmp = t_0;
} else if (z <= 2.7e-204) {
tmp = t_1;
} else if (z <= 1.25e-162) {
tmp = t_0;
} else if (z <= 8.5e-42) {
tmp = t_1;
} 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) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = x + ((-1.0d0) / x)
t_1 = x + (y / 1.1283791670955126d0)
if (z <= (-3.8d-38)) then
tmp = t_0
else if (z <= 2.7d-204) then
tmp = t_1
else if (z <= 1.25d-162) then
tmp = t_0
else if (z <= 8.5d-42) then
tmp = t_1
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x + (-1.0 / x);
double t_1 = x + (y / 1.1283791670955126);
double tmp;
if (z <= -3.8e-38) {
tmp = t_0;
} else if (z <= 2.7e-204) {
tmp = t_1;
} else if (z <= 1.25e-162) {
tmp = t_0;
} else if (z <= 8.5e-42) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): t_0 = x + (-1.0 / x) t_1 = x + (y / 1.1283791670955126) tmp = 0 if z <= -3.8e-38: tmp = t_0 elif z <= 2.7e-204: tmp = t_1 elif z <= 1.25e-162: tmp = t_0 elif z <= 8.5e-42: tmp = t_1 else: tmp = x return tmp
function code(x, y, z) t_0 = Float64(x + Float64(-1.0 / x)) t_1 = Float64(x + Float64(y / 1.1283791670955126)) tmp = 0.0 if (z <= -3.8e-38) tmp = t_0; elseif (z <= 2.7e-204) tmp = t_1; elseif (z <= 1.25e-162) tmp = t_0; elseif (z <= 8.5e-42) tmp = t_1; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) t_0 = x + (-1.0 / x); t_1 = x + (y / 1.1283791670955126); tmp = 0.0; if (z <= -3.8e-38) tmp = t_0; elseif (z <= 2.7e-204) tmp = t_1; elseif (z <= 1.25e-162) tmp = t_0; elseif (z <= 8.5e-42) tmp = t_1; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x + N[(y / 1.1283791670955126), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.8e-38], t$95$0, If[LessEqual[z, 2.7e-204], t$95$1, If[LessEqual[z, 1.25e-162], t$95$0, If[LessEqual[z, 8.5e-42], t$95$1, x]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x + \frac{-1}{x}\\
t_1 := x + \frac{y}{1.1283791670955126}\\
\mathbf{if}\;z \leq -3.8 \cdot 10^{-38}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;z \leq 2.7 \cdot 10^{-204}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.25 \cdot 10^{-162}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;z \leq 8.5 \cdot 10^{-42}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -3.8e-38 or 2.69999999999999991e-204 < z < 1.25000000000000004e-162Initial program 91.2%
remove-double-neg91.2%
neg-mul-191.2%
associate-/l*91.2%
neg-mul-191.2%
associate-/r*91.2%
div-sub91.5%
metadata-eval91.5%
associate-/l*91.5%
*-commutative91.5%
associate-*l*91.5%
neg-mul-191.5%
/-rgt-identity91.5%
div-sub91.3%
Simplified100.0%
Taylor expanded in x around inf 94.3%
if -3.8e-38 < z < 2.69999999999999991e-204 or 1.25000000000000004e-162 < z < 8.4999999999999996e-42Initial program 99.8%
Taylor expanded in z around 0 99.8%
Taylor expanded in y around 0 80.1%
Taylor expanded in z around 0 80.1%
if 8.4999999999999996e-42 < z Initial program 93.4%
remove-double-neg93.4%
neg-mul-193.4%
associate-/l*93.4%
neg-mul-193.4%
associate-/r*93.4%
div-sub93.4%
metadata-eval93.4%
associate-/l*93.4%
*-commutative93.4%
associate-*l*93.4%
neg-mul-193.4%
/-rgt-identity93.4%
div-sub93.4%
Simplified99.9%
Taylor expanded in x around inf 96.9%
Final simplification89.1%
(FPCore (x y z)
:precision binary64
(if (<= z -1.8e+198)
x
(if (<= z -7.2e+68)
(/ -1.0 x)
(if (<= z 7.2e-40) (+ x (/ y 1.1283791670955126)) x))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.8e+198) {
tmp = x;
} else if (z <= -7.2e+68) {
tmp = -1.0 / x;
} else if (z <= 7.2e-40) {
tmp = x + (y / 1.1283791670955126);
} 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 <= (-1.8d+198)) then
tmp = x
else if (z <= (-7.2d+68)) then
tmp = (-1.0d0) / x
else if (z <= 7.2d-40) then
tmp = x + (y / 1.1283791670955126d0)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -1.8e+198) {
tmp = x;
} else if (z <= -7.2e+68) {
tmp = -1.0 / x;
} else if (z <= 7.2e-40) {
tmp = x + (y / 1.1283791670955126);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -1.8e+198: tmp = x elif z <= -7.2e+68: tmp = -1.0 / x elif z <= 7.2e-40: tmp = x + (y / 1.1283791670955126) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -1.8e+198) tmp = x; elseif (z <= -7.2e+68) tmp = Float64(-1.0 / x); elseif (z <= 7.2e-40) tmp = Float64(x + Float64(y / 1.1283791670955126)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -1.8e+198) tmp = x; elseif (z <= -7.2e+68) tmp = -1.0 / x; elseif (z <= 7.2e-40) tmp = x + (y / 1.1283791670955126); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -1.8e+198], x, If[LessEqual[z, -7.2e+68], N[(-1.0 / x), $MachinePrecision], If[LessEqual[z, 7.2e-40], N[(x + N[(y / 1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.8 \cdot 10^{+198}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -7.2 \cdot 10^{+68}:\\
\;\;\;\;\frac{-1}{x}\\
\mathbf{elif}\;z \leq 7.2 \cdot 10^{-40}:\\
\;\;\;\;x + \frac{y}{1.1283791670955126}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.8000000000000001e198 or 7.2e-40 < z Initial program 94.1%
remove-double-neg94.1%
neg-mul-194.1%
associate-/l*94.1%
neg-mul-194.1%
associate-/r*94.1%
div-sub94.1%
metadata-eval94.1%
associate-/l*94.1%
*-commutative94.1%
associate-*l*94.1%
neg-mul-194.1%
/-rgt-identity94.1%
div-sub94.1%
Simplified100.0%
Taylor expanded in x around inf 89.2%
if -1.8000000000000001e198 < z < -7.1999999999999998e68Initial program 83.0%
remove-double-neg83.0%
neg-mul-183.0%
associate-/l*83.1%
neg-mul-183.1%
associate-/r*83.1%
div-sub83.8%
metadata-eval83.8%
associate-/l*83.8%
*-commutative83.8%
associate-*l*83.8%
neg-mul-183.8%
/-rgt-identity83.8%
div-sub83.3%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Taylor expanded in x around 0 71.9%
if -7.1999999999999998e68 < z < 7.2e-40Initial program 99.1%
Taylor expanded in z around 0 98.4%
Taylor expanded in y around 0 73.3%
Taylor expanded in z around 0 73.0%
Final simplification78.2%
(FPCore (x y z) :precision binary64 (if (<= z -32000000000.0) (+ x (/ -1.0 x)) (if (<= z 4.0) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -32000000000.0) {
tmp = x + (-1.0 / x);
} else if (z <= 4.0) {
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 <= (-32000000000.0d0)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 4.0d0) 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 <= -32000000000.0) {
tmp = x + (-1.0 / x);
} else if (z <= 4.0) {
tmp = x + (y / (1.1283791670955126 - (x * y)));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -32000000000.0: tmp = x + (-1.0 / x) elif z <= 4.0: tmp = x + (y / (1.1283791670955126 - (x * y))) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -32000000000.0) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 4.0) 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 <= -32000000000.0) tmp = x + (-1.0 / x); elseif (z <= 4.0) tmp = x + (y / (1.1283791670955126 - (x * y))); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -32000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.0], 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 -32000000000:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 4:\\
\;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -3.2e10Initial program 87.8%
remove-double-neg87.8%
neg-mul-187.8%
associate-/l*87.9%
neg-mul-187.9%
associate-/r*87.9%
div-sub88.3%
metadata-eval88.3%
associate-/l*88.3%
*-commutative88.3%
associate-*l*88.3%
neg-mul-188.3%
/-rgt-identity88.3%
div-sub88.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if -3.2e10 < z < 4Initial program 99.8%
Taylor expanded in z around 0 99.1%
if 4 < z Initial program 92.3%
remove-double-neg92.3%
neg-mul-192.3%
associate-/l*92.3%
neg-mul-192.3%
associate-/r*92.3%
div-sub92.3%
metadata-eval92.3%
associate-/l*92.3%
*-commutative92.3%
associate-*l*92.3%
neg-mul-192.3%
/-rgt-identity92.3%
div-sub92.3%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification99.5%
(FPCore (x y z) :precision binary64 (if (<= z -32000000000.0) (+ x (/ -1.0 x)) (if (<= z 4.0) (+ x (/ -1.0 (+ x (/ -1.1283791670955126 y)))) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -32000000000.0) {
tmp = x + (-1.0 / x);
} else if (z <= 4.0) {
tmp = x + (-1.0 / (x + (-1.1283791670955126 / 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 <= (-32000000000.0d0)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 4.0d0) then
tmp = x + ((-1.0d0) / (x + ((-1.1283791670955126d0) / y)))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -32000000000.0) {
tmp = x + (-1.0 / x);
} else if (z <= 4.0) {
tmp = x + (-1.0 / (x + (-1.1283791670955126 / y)));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -32000000000.0: tmp = x + (-1.0 / x) elif z <= 4.0: tmp = x + (-1.0 / (x + (-1.1283791670955126 / y))) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -32000000000.0) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 4.0) tmp = Float64(x + Float64(-1.0 / Float64(x + Float64(-1.1283791670955126 / y)))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -32000000000.0) tmp = x + (-1.0 / x); elseif (z <= 4.0) tmp = x + (-1.0 / (x + (-1.1283791670955126 / y))); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -32000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.0], N[(x + N[(-1.0 / N[(x + N[(-1.1283791670955126 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -32000000000:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 4:\\
\;\;\;\;x + \frac{-1}{x + \frac{-1.1283791670955126}{y}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -3.2e10Initial program 87.8%
remove-double-neg87.8%
neg-mul-187.8%
associate-/l*87.9%
neg-mul-187.9%
associate-/r*87.9%
div-sub88.3%
metadata-eval88.3%
associate-/l*88.3%
*-commutative88.3%
associate-*l*88.3%
neg-mul-188.3%
/-rgt-identity88.3%
div-sub88.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if -3.2e10 < z < 4Initial program 99.8%
remove-double-neg99.8%
neg-mul-199.8%
associate-/l*99.8%
neg-mul-199.8%
associate-/r*99.8%
div-sub99.8%
metadata-eval99.8%
associate-/l*99.8%
*-commutative99.8%
associate-*l*99.8%
neg-mul-199.8%
/-rgt-identity99.8%
div-sub99.8%
Simplified99.8%
Taylor expanded in z around 0 99.1%
cancel-sign-sub-inv99.1%
metadata-eval99.1%
associate-*r/99.1%
metadata-eval99.1%
Simplified99.1%
if 4 < z Initial program 92.3%
remove-double-neg92.3%
neg-mul-192.3%
associate-/l*92.3%
neg-mul-192.3%
associate-/r*92.3%
div-sub92.3%
metadata-eval92.3%
associate-/l*92.3%
*-commutative92.3%
associate-*l*92.3%
neg-mul-192.3%
/-rgt-identity92.3%
div-sub92.3%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification99.5%
(FPCore (x y z) :precision binary64 (if (<= x -6e-87) x (if (<= x 8.2e-230) (* y 0.8862269254527579) x)))
double code(double x, double y, double z) {
double tmp;
if (x <= -6e-87) {
tmp = x;
} else if (x <= 8.2e-230) {
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 <= (-6d-87)) then
tmp = x
else if (x <= 8.2d-230) 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 <= -6e-87) {
tmp = x;
} else if (x <= 8.2e-230) {
tmp = y * 0.8862269254527579;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -6e-87: tmp = x elif x <= 8.2e-230: tmp = y * 0.8862269254527579 else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (x <= -6e-87) tmp = x; elseif (x <= 8.2e-230) tmp = Float64(y * 0.8862269254527579); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -6e-87) tmp = x; elseif (x <= 8.2e-230) tmp = y * 0.8862269254527579; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -6e-87], x, If[LessEqual[x, 8.2e-230], N[(y * 0.8862269254527579), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6 \cdot 10^{-87}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 8.2 \cdot 10^{-230}:\\
\;\;\;\;y \cdot 0.8862269254527579\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -6.00000000000000033e-87 or 8.2000000000000003e-230 < x Initial program 96.5%
remove-double-neg96.5%
neg-mul-196.5%
associate-/l*96.5%
neg-mul-196.5%
associate-/r*96.5%
div-sub96.5%
metadata-eval96.5%
associate-/l*96.5%
*-commutative96.5%
associate-*l*96.5%
neg-mul-196.5%
/-rgt-identity96.5%
div-sub96.5%
Simplified100.0%
Taylor expanded in x around inf 80.0%
if -6.00000000000000033e-87 < x < 8.2000000000000003e-230Initial program 90.8%
remove-double-neg90.8%
neg-mul-190.8%
associate-/l*90.8%
neg-mul-190.8%
associate-/r*90.8%
div-sub91.2%
metadata-eval91.2%
associate-/l*91.2%
*-commutative91.2%
associate-*l*91.2%
neg-mul-191.2%
/-rgt-identity91.2%
div-sub90.9%
Simplified99.7%
Taylor expanded in z around 0 70.1%
Taylor expanded in x around 0 49.1%
*-commutative49.1%
Simplified49.1%
Taylor expanded in x around 0 46.7%
*-commutative46.7%
Simplified46.7%
Final simplification72.9%
(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.3%
remove-double-neg95.3%
neg-mul-195.3%
associate-/l*95.3%
neg-mul-195.3%
associate-/r*95.3%
div-sub95.4%
metadata-eval95.4%
associate-/l*95.4%
*-commutative95.4%
associate-*l*95.4%
neg-mul-195.4%
/-rgt-identity95.4%
div-sub95.3%
Simplified99.9%
Taylor expanded in x around inf 66.5%
Final simplification66.5%
(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 2024020
(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)))))