
(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 8 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)) (- x (/ y (fma x y (* (exp z) -1.1283791670955126))))))
double code(double x, double y, double z) {
double tmp;
if (exp(z) <= 0.0) {
tmp = x + (-1.0 / x);
} else {
tmp = x - (y / fma(x, y, (exp(z) * -1.1283791670955126)));
}
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 / fma(x, y, Float64(exp(z) * -1.1283791670955126)))); end return 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[(x * y + N[(N[Exp[z], $MachinePrecision] * -1.1283791670955126), $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}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}\\
\end{array}
\end{array}
if (exp.f64 z) < 0.0Initial program 82.9%
remove-double-neg82.9%
distribute-frac-neg82.9%
unsub-neg82.9%
distribute-frac-neg82.9%
distribute-neg-frac282.9%
neg-sub082.6%
associate--r-82.6%
neg-sub083.3%
+-commutative83.3%
fma-define83.3%
*-commutative83.3%
distribute-rgt-neg-in83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in y around inf 100.0%
if 0.0 < (exp.f64 z) Initial program 99.3%
remove-double-neg99.3%
distribute-frac-neg99.3%
unsub-neg99.3%
distribute-frac-neg99.3%
distribute-neg-frac299.3%
neg-sub099.3%
associate--r-99.3%
neg-sub099.3%
+-commutative99.3%
fma-define99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
metadata-eval99.9%
Simplified99.9%
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 (+ (* x y) (* z -1.1283791670955126)))))
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 - ((x * y) + (z * -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 (exp(z) <= 0.0d0) then
tmp = x + ((-1.0d0) / x)
else if (exp(z) <= 2.0d0) then
tmp = x + (y / (1.1283791670955126d0 - ((x * y) + (z * (-1.1283791670955126d0)))))
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 - ((x * y) + (z * -1.1283791670955126))));
} 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 - ((x * y) + (z * -1.1283791670955126)))) 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(1.1283791670955126 - Float64(Float64(x * y) + Float64(z * -1.1283791670955126))))); 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 - ((x * y) + (z * -1.1283791670955126)))); 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[(1.1283791670955126 - N[(N[(x * y), $MachinePrecision] + N[(z * -1.1283791670955126), $MachinePrecision]), $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}{1.1283791670955126 - \left(x \cdot y + z \cdot -1.1283791670955126\right)}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if (exp.f64 z) < 0.0Initial program 82.9%
remove-double-neg82.9%
distribute-frac-neg82.9%
unsub-neg82.9%
distribute-frac-neg82.9%
distribute-neg-frac282.9%
neg-sub082.6%
associate--r-82.6%
neg-sub083.3%
+-commutative83.3%
fma-define83.3%
*-commutative83.3%
distribute-rgt-neg-in83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in y around inf 100.0%
if 0.0 < (exp.f64 z) < 2Initial program 99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
unsub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-frac299.8%
neg-sub099.8%
associate--r-99.8%
neg-sub099.8%
+-commutative99.8%
fma-define99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in z around 0 98.7%
if 2 < (exp.f64 z) Initial program 98.4%
remove-double-neg98.4%
distribute-frac-neg98.4%
unsub-neg98.4%
distribute-frac-neg98.4%
distribute-neg-frac298.4%
neg-sub098.4%
associate--r-98.4%
neg-sub098.4%
+-commutative98.4%
fma-define100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 54.5%
Taylor expanded in x around inf 100.0%
Final simplification99.4%
(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 82.9%
remove-double-neg82.9%
distribute-frac-neg82.9%
unsub-neg82.9%
distribute-frac-neg82.9%
distribute-neg-frac282.9%
neg-sub082.6%
associate--r-82.6%
neg-sub083.3%
+-commutative83.3%
fma-define83.3%
*-commutative83.3%
distribute-rgt-neg-in83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in y around inf 100.0%
if 0.0 < (exp.f64 z) Initial program 99.3%
Final simplification99.5%
(FPCore (x y z)
:precision binary64
(if (<= z 1.65e-289)
(+ x (/ -1.0 x))
(if (<= z 2.1e-230)
(* y 0.8862269254527579)
(if (<= z 1.66e-183) x (if (<= z 5.5e-169) (/ y 1.1283791670955126) x)))))
double code(double x, double y, double z) {
double tmp;
if (z <= 1.65e-289) {
tmp = x + (-1.0 / x);
} else if (z <= 2.1e-230) {
tmp = y * 0.8862269254527579;
} else if (z <= 1.66e-183) {
tmp = x;
} else if (z <= 5.5e-169) {
tmp = 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.65d-289) then
tmp = x + ((-1.0d0) / x)
else if (z <= 2.1d-230) then
tmp = y * 0.8862269254527579d0
else if (z <= 1.66d-183) then
tmp = x
else if (z <= 5.5d-169) then
tmp = 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.65e-289) {
tmp = x + (-1.0 / x);
} else if (z <= 2.1e-230) {
tmp = y * 0.8862269254527579;
} else if (z <= 1.66e-183) {
tmp = x;
} else if (z <= 5.5e-169) {
tmp = y / 1.1283791670955126;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= 1.65e-289: tmp = x + (-1.0 / x) elif z <= 2.1e-230: tmp = y * 0.8862269254527579 elif z <= 1.66e-183: tmp = x elif z <= 5.5e-169: tmp = y / 1.1283791670955126 else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= 1.65e-289) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 2.1e-230) tmp = Float64(y * 0.8862269254527579); elseif (z <= 1.66e-183) tmp = x; elseif (z <= 5.5e-169) tmp = Float64(y / 1.1283791670955126); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= 1.65e-289) tmp = x + (-1.0 / x); elseif (z <= 2.1e-230) tmp = y * 0.8862269254527579; elseif (z <= 1.66e-183) tmp = x; elseif (z <= 5.5e-169) tmp = y / 1.1283791670955126; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, 1.65e-289], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.1e-230], N[(y * 0.8862269254527579), $MachinePrecision], If[LessEqual[z, 1.66e-183], x, If[LessEqual[z, 5.5e-169], N[(y / 1.1283791670955126), $MachinePrecision], x]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 1.65 \cdot 10^{-289}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 2.1 \cdot 10^{-230}:\\
\;\;\;\;y \cdot 0.8862269254527579\\
\mathbf{elif}\;z \leq 1.66 \cdot 10^{-183}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{-169}:\\
\;\;\;\;\frac{y}{1.1283791670955126}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < 1.64999999999999999e-289Initial program 90.8%
remove-double-neg90.8%
distribute-frac-neg90.8%
unsub-neg90.8%
distribute-frac-neg90.8%
distribute-neg-frac290.8%
neg-sub090.6%
associate--r-90.6%
neg-sub091.0%
+-commutative91.0%
fma-define91.0%
*-commutative91.0%
distribute-rgt-neg-in91.0%
metadata-eval91.0%
Simplified91.0%
Taylor expanded in y around inf 87.1%
if 1.64999999999999999e-289 < z < 2.0999999999999998e-230Initial program 99.5%
remove-double-neg99.5%
distribute-frac-neg99.5%
unsub-neg99.5%
distribute-frac-neg99.5%
distribute-neg-frac299.5%
neg-sub099.5%
associate--r-99.5%
neg-sub099.5%
+-commutative99.5%
fma-define99.5%
*-commutative99.5%
distribute-rgt-neg-in99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in z around 0 99.5%
Taylor expanded in x around 0 61.1%
if 2.0999999999999998e-230 < z < 1.66e-183 or 5.4999999999999994e-169 < z Initial program 99.0%
remove-double-neg99.0%
distribute-frac-neg99.0%
unsub-neg99.0%
distribute-frac-neg99.0%
distribute-neg-frac299.0%
neg-sub099.0%
associate--r-99.0%
neg-sub099.0%
+-commutative99.0%
fma-define99.9%
*-commutative99.9%
distribute-rgt-neg-in99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in y around inf 54.9%
Taylor expanded in x around inf 87.8%
if 1.66e-183 < z < 5.4999999999999994e-169Initial program 99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
unsub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-frac299.8%
neg-sub099.8%
associate--r-99.8%
neg-sub099.8%
+-commutative99.8%
fma-define99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in z around 0 99.8%
Taylor expanded in x around 0 71.7%
*-commutative71.7%
metadata-eval71.7%
distribute-rgt-neg-in71.7%
metadata-eval71.4%
div-inv71.9%
distribute-neg-frac271.9%
metadata-eval71.9%
Applied egg-rr71.9%
Final simplification86.1%
(FPCore (x y z) :precision binary64 (if (<= z -1.5e-305) (+ x (/ -1.0 x)) (if (<= z 0.000112) (+ x (* -0.8862269254527579 (- (* z y) y))) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.5e-305) {
tmp = x + (-1.0 / x);
} else if (z <= 0.000112) {
tmp = x + (-0.8862269254527579 * ((z * y) - 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 <= (-1.5d-305)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 0.000112d0) then
tmp = x + ((-0.8862269254527579d0) * ((z * y) - y))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -1.5e-305) {
tmp = x + (-1.0 / x);
} else if (z <= 0.000112) {
tmp = x + (-0.8862269254527579 * ((z * y) - y));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -1.5e-305: tmp = x + (-1.0 / x) elif z <= 0.000112: tmp = x + (-0.8862269254527579 * ((z * y) - y)) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -1.5e-305) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 0.000112) tmp = Float64(x + Float64(-0.8862269254527579 * Float64(Float64(z * y) - y))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -1.5e-305) tmp = x + (-1.0 / x); elseif (z <= 0.000112) tmp = x + (-0.8862269254527579 * ((z * y) - y)); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -1.5e-305], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.000112], N[(x + N[(-0.8862269254527579 * N[(N[(z * y), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.5 \cdot 10^{-305}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 0.000112:\\
\;\;\;\;x + -0.8862269254527579 \cdot \left(z \cdot y - y\right)\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.5000000000000001e-305Initial program 90.5%
remove-double-neg90.5%
distribute-frac-neg90.5%
unsub-neg90.5%
distribute-frac-neg90.5%
distribute-neg-frac290.5%
neg-sub090.4%
associate--r-90.4%
neg-sub090.7%
+-commutative90.7%
fma-define90.8%
*-commutative90.8%
distribute-rgt-neg-in90.8%
metadata-eval90.8%
Simplified90.8%
Taylor expanded in y around inf 87.5%
if -1.5000000000000001e-305 < z < 1.11999999999999998e-4Initial program 99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
unsub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-frac299.8%
neg-sub099.8%
associate--r-99.8%
neg-sub099.8%
+-commutative99.8%
fma-define99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in y around 0 86.1%
Taylor expanded in z around 0 86.1%
mul-1-neg86.1%
unsub-neg86.1%
Simplified86.1%
if 1.11999999999999998e-4 < z Initial program 98.5%
remove-double-neg98.5%
distribute-frac-neg98.5%
unsub-neg98.5%
distribute-frac-neg98.5%
distribute-neg-frac298.5%
neg-sub098.5%
associate--r-98.5%
neg-sub098.5%
+-commutative98.5%
fma-define100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 54.4%
Taylor expanded in x around inf 99.1%
Final simplification90.1%
(FPCore (x y z) :precision binary64 (if (<= z -1650000000000.0) (+ x (/ -1.0 x)) (if (<= z 128.0) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -1650000000000.0) {
tmp = x + (-1.0 / x);
} else if (z <= 128.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 <= (-1650000000000.0d0)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 128.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 <= -1650000000000.0) {
tmp = x + (-1.0 / x);
} else if (z <= 128.0) {
tmp = x + (y / (1.1283791670955126 - (x * y)));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -1650000000000.0: tmp = x + (-1.0 / x) elif z <= 128.0: tmp = x + (y / (1.1283791670955126 - (x * y))) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -1650000000000.0) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 128.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 <= -1650000000000.0) tmp = x + (-1.0 / x); elseif (z <= 128.0) tmp = x + (y / (1.1283791670955126 - (x * y))); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -1650000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 128.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 -1650000000000:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 128:\\
\;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.65e12Initial program 82.4%
remove-double-neg82.4%
distribute-frac-neg82.4%
unsub-neg82.4%
distribute-frac-neg82.4%
distribute-neg-frac282.4%
neg-sub082.1%
associate--r-82.1%
neg-sub082.8%
+-commutative82.8%
fma-define82.8%
*-commutative82.8%
distribute-rgt-neg-in82.8%
metadata-eval82.8%
Simplified82.8%
Taylor expanded in y around inf 100.0%
if -1.65e12 < z < 128Initial program 99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
unsub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-frac299.8%
neg-sub099.8%
associate--r-99.8%
neg-sub099.8%
+-commutative99.8%
fma-define99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in z around 0 98.5%
if 128 < z Initial program 98.4%
remove-double-neg98.4%
distribute-frac-neg98.4%
unsub-neg98.4%
distribute-frac-neg98.4%
distribute-neg-frac298.4%
neg-sub098.4%
associate--r-98.4%
neg-sub098.4%
+-commutative98.4%
fma-define100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 54.5%
Taylor expanded in x around inf 100.0%
Final simplification99.3%
(FPCore (x y z) :precision binary64 (if (<= z -7.5e-307) (+ x (/ -1.0 x)) (if (<= z 8e-5) (- x (/ y -1.1283791670955126)) x)))
double code(double x, double y, double z) {
double tmp;
if (z <= -7.5e-307) {
tmp = x + (-1.0 / x);
} else if (z <= 8e-5) {
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 <= (-7.5d-307)) then
tmp = x + ((-1.0d0) / x)
else if (z <= 8d-5) 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 <= -7.5e-307) {
tmp = x + (-1.0 / x);
} else if (z <= 8e-5) {
tmp = x - (y / -1.1283791670955126);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -7.5e-307: tmp = x + (-1.0 / x) elif z <= 8e-5: tmp = x - (y / -1.1283791670955126) else: tmp = x return tmp
function code(x, y, z) tmp = 0.0 if (z <= -7.5e-307) tmp = Float64(x + Float64(-1.0 / x)); elseif (z <= 8e-5) 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 <= -7.5e-307) tmp = x + (-1.0 / x); elseif (z <= 8e-5) tmp = x - (y / -1.1283791670955126); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -7.5e-307], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8e-5], N[(x - N[(y / -1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.5 \cdot 10^{-307}:\\
\;\;\;\;x + \frac{-1}{x}\\
\mathbf{elif}\;z \leq 8 \cdot 10^{-5}:\\
\;\;\;\;x - \frac{y}{-1.1283791670955126}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -7.5000000000000006e-307Initial program 90.5%
remove-double-neg90.5%
distribute-frac-neg90.5%
unsub-neg90.5%
distribute-frac-neg90.5%
distribute-neg-frac290.5%
neg-sub090.4%
associate--r-90.4%
neg-sub090.7%
+-commutative90.7%
fma-define90.8%
*-commutative90.8%
distribute-rgt-neg-in90.8%
metadata-eval90.8%
Simplified90.8%
Taylor expanded in y around inf 87.5%
if -7.5000000000000006e-307 < z < 8.00000000000000065e-5Initial program 99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
unsub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-frac299.8%
neg-sub099.8%
associate--r-99.8%
neg-sub099.8%
+-commutative99.8%
fma-define99.8%
*-commutative99.8%
distribute-rgt-neg-in99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in z around 0 98.8%
Taylor expanded in x around 0 85.7%
if 8.00000000000000065e-5 < z Initial program 98.5%
remove-double-neg98.5%
distribute-frac-neg98.5%
unsub-neg98.5%
distribute-frac-neg98.5%
distribute-neg-frac298.5%
neg-sub098.5%
associate--r-98.5%
neg-sub098.5%
+-commutative98.5%
fma-define100.0%
*-commutative100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 54.4%
Taylor expanded in x around inf 99.1%
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 94.8%
remove-double-neg94.8%
distribute-frac-neg94.8%
unsub-neg94.8%
distribute-frac-neg94.8%
distribute-neg-frac294.8%
neg-sub094.8%
associate--r-94.8%
neg-sub095.0%
+-commutative95.0%
fma-define95.4%
*-commutative95.4%
distribute-rgt-neg-in95.4%
metadata-eval95.4%
Simplified95.4%
Taylor expanded in y around inf 68.9%
Taylor expanded in x around inf 70.1%
Final simplification70.1%
(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 2024039
(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)))))