
(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 9 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
(if (<= (exp z) 0.0)
(+ x (/ -1.0 x))
(if (<= (exp z) 1.000000002)
(+ x (/ y (- (* 1.1283791670955126 (+ 1.0 z)) (* 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.000000002) {
tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (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.000000002d0) then
tmp = x + (y / ((1.1283791670955126d0 * (1.0d0 + z)) - (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.000000002) {
tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (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.000000002: tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (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.000000002) tmp = Float64(x + Float64(y / Float64(Float64(1.1283791670955126 * Float64(1.0 + z)) - 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.000000002) tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (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.000000002], N[(x + N[(y / N[(N[(1.1283791670955126 * N[(1.0 + z), $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.000000002:\\
\;\;\;\;x + \frac{y}{1.1283791670955126 \cdot \left(1 + z\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.9%
*-lft-identity88.9%
associate-/l*88.9%
div-sub89.1%
associate-*r/89.1%
/-rgt-identity89.1%
metadata-eval89.1%
associate-/l*89.1%
*-commutative89.1%
neg-mul-189.1%
associate-/l*89.1%
associate-*r*89.1%
*-commutative89.1%
neg-mul-189.1%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
if 0.0 < (exp.f64 z) < 1.00000000199999994Initial program 99.9%
Taylor expanded in z around 0 99.9%
*-commutative99.9%
distribute-rgt1-in99.9%
Applied egg-rr99.9%
if 1.00000000199999994 < (exp.f64 z) Initial program 92.9%
*-lft-identity92.9%
associate-/l*92.9%
div-sub92.9%
associate-*r/92.9%
/-rgt-identity92.9%
metadata-eval92.9%
associate-/l*92.9%
*-commutative92.9%
neg-mul-192.9%
associate-/l*92.9%
associate-*r*92.9%
*-commutative92.9%
neg-mul-192.9%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
associate-*r/100.0%
Simplified100.0%
Final simplification100.0%
(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.4%
*-lft-identity95.4%
associate-/l*95.4%
div-sub95.4%
associate-*r/95.4%
/-rgt-identity95.4%
metadata-eval95.4%
associate-/l*95.4%
*-commutative95.4%
neg-mul-195.4%
associate-/l*95.4%
associate-*r*95.4%
*-commutative95.4%
neg-mul-195.4%
associate-/l*99.9%
*-inverses99.9%
/-rgt-identity99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (x y z)
:precision binary64
(if (<= z -2.1e+14)
(+ x (/ -1.0 x))
(if (<= z 0.02)
(+ x (/ y (- (* 1.1283791670955126 (+ 1.0 z)) (* x y))))
x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -2.1e+14) {
tmp = x + (-1.0 / x);
} else if (z <= 0.02) {
tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (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 <= (-2.1d+14)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 0.02d0) then
tmp = x + (y / ((1.1283791670955126d0 * (1.0d0 + z)) - (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 <= -2.1e+14) {
tmp = x + (-1.0 / x);
} else if (z <= 0.02) {
tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (x * y)));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -2.1e+14: tmp = x + (-1.0 / x) elif z <= 0.02: tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (x * y))) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -2.1e+14) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 0.02) tmp = Float64(x + Float64(y / Float64(Float64(1.1283791670955126 * Float64(1.0 + z)) - Float64(x * y)))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -2.1e+14) tmp = x + (-1.0 / x); elseif (z <= 0.02) tmp = x + (y / ((1.1283791670955126 * (1.0 + z)) - (x * y))); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -2.1e+14], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.02], N[(x + N[(y / N[(N[(1.1283791670955126 * N[(1.0 + z), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.1 \cdot 10^{+14}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 0.02:\\
\;\;\;\;x + \frac{y}{1.1283791670955126 \cdot \left(1 + z\right) - x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.1e14Initial program 88.3%
*-lft-identity88.3%
associate-/l*88.3%
div-sub88.6%
associate-*r/88.6%
/-rgt-identity88.6%
metadata-eval88.6%
associate-/l*88.6%
*-commutative88.6%
neg-mul-188.6%
associate-/l*88.6%
associate-*r*88.6%
*-commutative88.6%
neg-mul-188.6%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
if -2.1e14 < z < 0.0200000000000000004Initial program 99.9%
Taylor expanded in z around 0 99.5%
*-commutative99.5%
distribute-rgt1-in99.5%
Applied egg-rr99.5%
if 0.0200000000000000004 < z Initial program 92.6%
*-lft-identity92.6%
associate-/l*92.6%
div-sub92.6%
associate-*r/92.6%
/-rgt-identity92.6%
metadata-eval92.6%
associate-/l*92.6%
*-commutative92.6%
neg-mul-192.6%
associate-/l*92.6%
associate-*r*92.6%
*-commutative92.6%
neg-mul-192.6%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in z around 0 62.9%
Taylor expanded in x around inf 100.0%
Final simplification99.7%
(FPCore (x y z) :precision binary64 (if (<= z -2.1e+14) (+ x (/ -1.0 x)) (if (<= z 0.02) (+ x (/ 1.0 (- (/ 1.1283791670955126 y) x))) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -2.1e+14) {
tmp = x + (-1.0 / x);
} else if (z <= 0.02) {
tmp = x + (1.0 / ((1.1283791670955126 / y) - 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 (z <= (-2.1d+14)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 0.02d0) then
tmp = x + (1.0d0 / ((1.1283791670955126d0 / y) - x))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -2.1e+14) {
tmp = x + (-1.0 / x);
} else if (z <= 0.02) {
tmp = x + (1.0 / ((1.1283791670955126 / y) - x));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -2.1e+14: tmp = x + (-1.0 / x) elif z <= 0.02: tmp = x + (1.0 / ((1.1283791670955126 / y) - x)) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -2.1e+14) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 0.02) tmp = Float64(x + Float64(1.0 / Float64(Float64(1.1283791670955126 / y) - x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -2.1e+14) tmp = x + (-1.0 / x); elseif (z <= 0.02) tmp = x + (1.0 / ((1.1283791670955126 / y) - x)); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -2.1e+14], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.02], N[(x + N[(1.0 / N[(N[(1.1283791670955126 / y), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.1 \cdot 10^{+14}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 0.02:\\
\;\;\;\;x + \frac{1}{\frac{1.1283791670955126}{y} - x}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.1e14Initial program 88.3%
*-lft-identity88.3%
associate-/l*88.3%
div-sub88.6%
associate-*r/88.6%
/-rgt-identity88.6%
metadata-eval88.6%
associate-/l*88.6%
*-commutative88.6%
neg-mul-188.6%
associate-/l*88.6%
associate-*r*88.6%
*-commutative88.6%
neg-mul-188.6%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
if -2.1e14 < z < 0.0200000000000000004Initial program 99.9%
*-lft-identity99.9%
associate-/l*99.9%
div-sub99.9%
associate-*r/99.8%
/-rgt-identity99.8%
metadata-eval99.8%
associate-/l*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
associate-*r*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
*-inverses99.8%
/-rgt-identity99.8%
Simplified99.8%
Taylor expanded in z around 0 99.1%
if 0.0200000000000000004 < z Initial program 92.6%
*-lft-identity92.6%
associate-/l*92.6%
div-sub92.6%
associate-*r/92.6%
/-rgt-identity92.6%
metadata-eval92.6%
associate-/l*92.6%
*-commutative92.6%
neg-mul-192.6%
associate-/l*92.6%
associate-*r*92.6%
*-commutative92.6%
neg-mul-192.6%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in z around 0 62.9%
Taylor expanded in x around inf 100.0%
Final simplification99.5%
(FPCore (x y z) :precision binary64 (if (<= z -2.1e+14) (+ x (/ -1.0 x)) (if (<= z 0.02) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -2.1e+14) {
tmp = x + (-1.0 / x);
} else if (z <= 0.02) {
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 <= (-2.1d+14)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 0.02d0) 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 <= -2.1e+14) {
tmp = x + (-1.0 / x);
} else if (z <= 0.02) {
tmp = x + (y / (1.1283791670955126 - (x * y)));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -2.1e+14: tmp = x + (-1.0 / x) elif z <= 0.02: tmp = x + (y / (1.1283791670955126 - (x * y))) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -2.1e+14) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 0.02) 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 <= -2.1e+14) tmp = x + (-1.0 / x); elseif (z <= 0.02) tmp = x + (y / (1.1283791670955126 - (x * y))); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -2.1e+14], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.02], 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 -2.1 \cdot 10^{+14}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 0.02:\\
\;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.1e14Initial program 88.3%
*-lft-identity88.3%
associate-/l*88.3%
div-sub88.6%
associate-*r/88.6%
/-rgt-identity88.6%
metadata-eval88.6%
associate-/l*88.6%
*-commutative88.6%
neg-mul-188.6%
associate-/l*88.6%
associate-*r*88.6%
*-commutative88.6%
neg-mul-188.6%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
if -2.1e14 < z < 0.0200000000000000004Initial program 99.9%
Taylor expanded in z around 0 99.1%
*-commutative99.1%
Simplified99.1%
if 0.0200000000000000004 < z Initial program 92.6%
*-lft-identity92.6%
associate-/l*92.6%
div-sub92.6%
associate-*r/92.6%
/-rgt-identity92.6%
metadata-eval92.6%
associate-/l*92.6%
*-commutative92.6%
neg-mul-192.6%
associate-/l*92.6%
associate-*r*92.6%
*-commutative92.6%
neg-mul-192.6%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in z around 0 62.9%
Taylor expanded in x around inf 100.0%
Final simplification99.5%
(FPCore (x y z) :precision binary64 (if (<= z -0.000106) x (if (<= z 6.2e-59) (+ x (* y 0.8862269254527579)) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -0.000106) {
tmp = x;
} else if (z <= 6.2e-59) {
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.000106d0)) then
tmp = x
else if (z <= 6.2d-59) 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.000106) {
tmp = x;
} else if (z <= 6.2e-59) {
tmp = x + (y * 0.8862269254527579);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -0.000106: tmp = x elif z <= 6.2e-59: tmp = x + (y * 0.8862269254527579) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -0.000106) tmp = x; elseif (z <= 6.2e-59) 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.000106) tmp = x; elseif (z <= 6.2e-59) tmp = x + (y * 0.8862269254527579); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -0.000106], x, If[LessEqual[z, 6.2e-59], N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -0.000106:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 6.2 \cdot 10^{-59}:\\
\;\;\;\;x + y \cdot 0.8862269254527579\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.06e-4 or 6.19999999999999998e-59 < z Initial program 91.8%
*-lft-identity91.8%
associate-/l*91.8%
div-sub91.9%
associate-*r/91.9%
/-rgt-identity91.9%
metadata-eval91.9%
associate-/l*91.9%
*-commutative91.9%
neg-mul-191.9%
associate-/l*91.9%
associate-*r*91.9%
*-commutative91.9%
neg-mul-191.9%
associate-/l*100.0%
*-inverses100.0%
/-rgt-identity100.0%
Simplified100.0%
Taylor expanded in z around 0 69.4%
Taylor expanded in x around inf 81.2%
if -1.06e-4 < z < 6.19999999999999998e-59Initial program 99.9%
*-lft-identity99.9%
associate-/l*99.9%
div-sub99.9%
associate-*r/99.8%
/-rgt-identity99.8%
metadata-eval99.8%
associate-/l*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
associate-*r*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
*-inverses99.8%
/-rgt-identity99.8%
Simplified99.8%
Taylor expanded in z around 0 99.9%
Taylor expanded in y around 0 80.7%
*-commutative80.7%
Simplified80.7%
Final simplification81.0%
(FPCore (x y z) :precision binary64 (if (<= z -4.8e-79) (+ x (/ -1.0 x)) (if (<= z 1.1e-58) (+ x (* y 0.8862269254527579)) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -4.8e-79) {
tmp = x + (-1.0 / x);
} else if (z <= 1.1e-58) {
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 <= (-4.8d-79)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 1.1d-58) 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 <= -4.8e-79) {
tmp = x + (-1.0 / x);
} else if (z <= 1.1e-58) {
tmp = x + (y * 0.8862269254527579);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -4.8e-79: tmp = x + (-1.0 / x) elif z <= 1.1e-58: tmp = x + (y * 0.8862269254527579) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -4.8e-79) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 1.1e-58) 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 <= -4.8e-79) tmp = x + (-1.0 / x); elseif (z <= 1.1e-58) tmp = x + (y * 0.8862269254527579); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -4.8e-79], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e-58], N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.8 \cdot 10^{-79}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-58}:\\
\;\;\;\;x + y \cdot 0.8862269254527579\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -4.80000000000000011e-79Initial program 90.6%
*-lft-identity90.6%
associate-/l*90.6%
div-sub90.8%
associate-*r/90.7%
/-rgt-identity90.7%
metadata-eval90.7%
associate-/l*90.7%
*-commutative90.7%
neg-mul-190.7%
associate-/l*90.7%
associate-*r*90.7%
*-commutative90.7%
neg-mul-190.7%
associate-/l*99.9%
*-inverses99.9%
/-rgt-identity99.9%
Simplified99.9%
Taylor expanded in y around inf 94.0%
if -4.80000000000000011e-79 < z < 1.10000000000000003e-58Initial program 99.9%
*-lft-identity99.9%
associate-/l*99.9%
div-sub99.9%
associate-*r/99.8%
/-rgt-identity99.8%
metadata-eval99.8%
associate-/l*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
associate-*r*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
*-inverses99.8%
/-rgt-identity99.8%
Simplified99.8%
Taylor expanded in z around 0 99.9%
Taylor expanded in y around 0 82.8%
*-commutative82.8%
Simplified82.8%
if 1.10000000000000003e-58 < z Initial program 94.0%
*-lft-identity94.0%
associate-/l*94.0%
div-sub94.0%
associate-*r/93.9%
/-rgt-identity93.9%
metadata-eval93.9%
associate-/l*93.9%
*-commutative93.9%
neg-mul-193.9%
associate-/l*93.9%
associate-*r*93.9%
*-commutative93.9%
neg-mul-193.9%
associate-/l*99.9%
*-inverses99.9%
/-rgt-identity99.9%
Simplified99.9%
Taylor expanded in z around 0 68.4%
Taylor expanded in x around inf 95.4%
Final simplification90.0%
(FPCore (x y z) :precision binary64 (if (<= z -3.5e-75) (+ x (/ -1.0 x)) (if (<= z 1.15e-60) (+ x (/ y 1.1283791670955126)) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -3.5e-75) {
tmp = x + (-1.0 / x);
} else if (z <= 1.15e-60) {
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 <= (-3.5d-75)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 1.15d-60) 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 <= -3.5e-75) {
tmp = x + (-1.0 / x);
} else if (z <= 1.15e-60) {
tmp = x + (y / 1.1283791670955126);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -3.5e-75: tmp = x + (-1.0 / x) elif z <= 1.15e-60: tmp = x + (y / 1.1283791670955126) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -3.5e-75) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 1.15e-60) 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 <= -3.5e-75) tmp = x + (-1.0 / x); elseif (z <= 1.15e-60) tmp = x + (y / 1.1283791670955126); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -3.5e-75], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.15e-60], N[(x + N[(y / 1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.5 \cdot 10^{-75}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 1.15 \cdot 10^{-60}:\\
\;\;\;\;x + \frac{y}{1.1283791670955126}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -3.49999999999999985e-75Initial program 90.6%
*-lft-identity90.6%
associate-/l*90.6%
div-sub90.8%
associate-*r/90.7%
/-rgt-identity90.7%
metadata-eval90.7%
associate-/l*90.7%
*-commutative90.7%
neg-mul-190.7%
associate-/l*90.7%
associate-*r*90.7%
*-commutative90.7%
neg-mul-190.7%
associate-/l*99.9%
*-inverses99.9%
/-rgt-identity99.9%
Simplified99.9%
Taylor expanded in y around inf 94.0%
if -3.49999999999999985e-75 < z < 1.1500000000000001e-60Initial program 99.9%
*-lft-identity99.9%
associate-/l*99.9%
div-sub99.9%
associate-*r/99.8%
/-rgt-identity99.8%
metadata-eval99.8%
associate-/l*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
associate-*r*99.8%
*-commutative99.8%
neg-mul-199.8%
associate-/l*99.8%
*-inverses99.8%
/-rgt-identity99.8%
Simplified99.8%
Taylor expanded in z around 0 99.9%
Taylor expanded in y around 0 82.8%
*-commutative82.8%
Simplified82.8%
metadata-eval82.8%
div-inv82.9%
Applied egg-rr82.9%
if 1.1500000000000001e-60 < z Initial program 94.0%
*-lft-identity94.0%
associate-/l*94.0%
div-sub94.0%
associate-*r/93.9%
/-rgt-identity93.9%
metadata-eval93.9%
associate-/l*93.9%
*-commutative93.9%
neg-mul-193.9%
associate-/l*93.9%
associate-*r*93.9%
*-commutative93.9%
neg-mul-193.9%
associate-/l*99.9%
*-inverses99.9%
/-rgt-identity99.9%
Simplified99.9%
Taylor expanded in z around 0 68.4%
Taylor expanded in x around inf 95.4%
Final simplification90.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 95.4%
*-lft-identity95.4%
associate-/l*95.4%
div-sub95.4%
associate-*r/95.4%
/-rgt-identity95.4%
metadata-eval95.4%
associate-/l*95.4%
*-commutative95.4%
neg-mul-195.4%
associate-/l*95.4%
associate-*r*95.4%
*-commutative95.4%
neg-mul-195.4%
associate-/l*99.9%
*-inverses99.9%
/-rgt-identity99.9%
Simplified99.9%
Taylor expanded in z around 0 82.8%
Taylor expanded in x around inf 74.4%
Final simplification74.4%
(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 2024010
(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)))))