
(FPCore (x y) :precision binary64 (- (- 1.0 (/ 1.0 (* x 9.0))) (/ y (* 3.0 (sqrt x)))))
double code(double x, double y) {
return (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * sqrt(x)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (1.0d0 - (1.0d0 / (x * 9.0d0))) - (y / (3.0d0 * sqrt(x)))
end function
public static double code(double x, double y) {
return (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * Math.sqrt(x)));
}
def code(x, y): return (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * math.sqrt(x)))
function code(x, y) return Float64(Float64(1.0 - Float64(1.0 / Float64(x * 9.0))) - Float64(y / Float64(3.0 * sqrt(x)))) end
function tmp = code(x, y) tmp = (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * sqrt(x))); end
code[x_, y_] := N[(N[(1.0 - N[(1.0 / N[(x * 9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y / N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(1 - \frac{1}{x \cdot 9}\right) - \frac{y}{3 \cdot \sqrt{x}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (- (- 1.0 (/ 1.0 (* x 9.0))) (/ y (* 3.0 (sqrt x)))))
double code(double x, double y) {
return (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * sqrt(x)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (1.0d0 - (1.0d0 / (x * 9.0d0))) - (y / (3.0d0 * sqrt(x)))
end function
public static double code(double x, double y) {
return (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * Math.sqrt(x)));
}
def code(x, y): return (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * math.sqrt(x)))
function code(x, y) return Float64(Float64(1.0 - Float64(1.0 / Float64(x * 9.0))) - Float64(y / Float64(3.0 * sqrt(x)))) end
function tmp = code(x, y) tmp = (1.0 - (1.0 / (x * 9.0))) - (y / (3.0 * sqrt(x))); end
code[x_, y_] := N[(N[(1.0 - N[(1.0 / N[(x * 9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y / N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(1 - \frac{1}{x \cdot 9}\right) - \frac{y}{3 \cdot \sqrt{x}}
\end{array}
(FPCore (x y) :precision binary64 (+ 1.0 (- (/ -1.0 (* x 9.0)) (/ (/ y 3.0) (sqrt x)))))
double code(double x, double y) {
return 1.0 + ((-1.0 / (x * 9.0)) - ((y / 3.0) / sqrt(x)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + (((-1.0d0) / (x * 9.0d0)) - ((y / 3.0d0) / sqrt(x)))
end function
public static double code(double x, double y) {
return 1.0 + ((-1.0 / (x * 9.0)) - ((y / 3.0) / Math.sqrt(x)));
}
def code(x, y): return 1.0 + ((-1.0 / (x * 9.0)) - ((y / 3.0) / math.sqrt(x)))
function code(x, y) return Float64(1.0 + Float64(Float64(-1.0 / Float64(x * 9.0)) - Float64(Float64(y / 3.0) / sqrt(x)))) end
function tmp = code(x, y) tmp = 1.0 + ((-1.0 / (x * 9.0)) - ((y / 3.0) / sqrt(x))); end
code[x_, y_] := N[(1.0 + N[(N[(-1.0 / N[(x * 9.0), $MachinePrecision]), $MachinePrecision] - N[(N[(y / 3.0), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(\frac{-1}{x \cdot 9} - \frac{\frac{y}{3}}{\sqrt{x}}\right)
\end{array}
Initial program 99.6%
associate--l-99.6%
+-commutative99.6%
+-commutative99.6%
associate-/r*99.6%
Simplified99.6%
Final simplification99.6%
(FPCore (x y)
:precision binary64
(if (<= y -5.5e+28)
(- 1.0 (/ y (sqrt (* x 9.0))))
(if (<= y 5e+56)
(+ 1.0 (/ -0.1111111111111111 x))
(- 1.0 (* y (* 0.3333333333333333 (sqrt (/ 1.0 x))))))))
double code(double x, double y) {
double tmp;
if (y <= -5.5e+28) {
tmp = 1.0 - (y / sqrt((x * 9.0)));
} else if (y <= 5e+56) {
tmp = 1.0 + (-0.1111111111111111 / x);
} else {
tmp = 1.0 - (y * (0.3333333333333333 * sqrt((1.0 / x))));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= (-5.5d+28)) then
tmp = 1.0d0 - (y / sqrt((x * 9.0d0)))
else if (y <= 5d+56) then
tmp = 1.0d0 + ((-0.1111111111111111d0) / x)
else
tmp = 1.0d0 - (y * (0.3333333333333333d0 * sqrt((1.0d0 / x))))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -5.5e+28) {
tmp = 1.0 - (y / Math.sqrt((x * 9.0)));
} else if (y <= 5e+56) {
tmp = 1.0 + (-0.1111111111111111 / x);
} else {
tmp = 1.0 - (y * (0.3333333333333333 * Math.sqrt((1.0 / x))));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -5.5e+28: tmp = 1.0 - (y / math.sqrt((x * 9.0))) elif y <= 5e+56: tmp = 1.0 + (-0.1111111111111111 / x) else: tmp = 1.0 - (y * (0.3333333333333333 * math.sqrt((1.0 / x)))) return tmp
function code(x, y) tmp = 0.0 if (y <= -5.5e+28) tmp = Float64(1.0 - Float64(y / sqrt(Float64(x * 9.0)))); elseif (y <= 5e+56) tmp = Float64(1.0 + Float64(-0.1111111111111111 / x)); else tmp = Float64(1.0 - Float64(y * Float64(0.3333333333333333 * sqrt(Float64(1.0 / x))))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -5.5e+28) tmp = 1.0 - (y / sqrt((x * 9.0))); elseif (y <= 5e+56) tmp = 1.0 + (-0.1111111111111111 / x); else tmp = 1.0 - (y * (0.3333333333333333 * sqrt((1.0 / x)))); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -5.5e+28], N[(1.0 - N[(y / N[Sqrt[N[(x * 9.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5e+56], N[(1.0 + N[(-0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision], N[(1.0 - N[(y * N[(0.3333333333333333 * N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.5 \cdot 10^{+28}:\\
\;\;\;\;1 - \frac{y}{\sqrt{x \cdot 9}}\\
\mathbf{elif}\;y \leq 5 \cdot 10^{+56}:\\
\;\;\;\;1 + \frac{-0.1111111111111111}{x}\\
\mathbf{else}:\\
\;\;\;\;1 - y \cdot \left(0.3333333333333333 \cdot \sqrt{\frac{1}{x}}\right)\\
\end{array}
\end{array}
if y < -5.5000000000000003e28Initial program 99.4%
*-commutative99.4%
associate-/r*99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in x around inf 92.1%
*-commutative92.1%
metadata-eval92.1%
sqrt-prod92.2%
pow1/292.2%
Applied egg-rr92.2%
unpow1/292.2%
Simplified92.2%
if -5.5000000000000003e28 < y < 5.00000000000000024e56Initial program 99.8%
associate--l-99.8%
sub-neg99.8%
+-commutative99.8%
distribute-neg-in99.8%
distribute-neg-frac99.8%
neg-mul-199.8%
*-commutative99.8%
associate-*r/99.8%
fma-def99.8%
associate-/r*99.8%
metadata-eval99.8%
*-commutative99.8%
associate-/r*99.7%
distribute-neg-frac99.7%
metadata-eval99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in y around 0 99.0%
if 5.00000000000000024e56 < y Initial program 99.3%
associate--l-99.3%
+-commutative99.3%
+-commutative99.3%
associate-/r*99.5%
Simplified99.5%
Taylor expanded in x around 0 99.5%
Taylor expanded in y around inf 95.8%
associate-*r*95.7%
*-commutative95.7%
associate-*l*95.8%
Simplified95.8%
Final simplification96.5%
(FPCore (x y) :precision binary64 (if (or (<= y -7.5e+28) (not (<= y 1.15e+56))) (- 1.0 (* (/ y (sqrt x)) 0.3333333333333333)) (+ 1.0 (/ -0.1111111111111111 x))))
double code(double x, double y) {
double tmp;
if ((y <= -7.5e+28) || !(y <= 1.15e+56)) {
tmp = 1.0 - ((y / sqrt(x)) * 0.3333333333333333);
} else {
tmp = 1.0 + (-0.1111111111111111 / x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-7.5d+28)) .or. (.not. (y <= 1.15d+56))) then
tmp = 1.0d0 - ((y / sqrt(x)) * 0.3333333333333333d0)
else
tmp = 1.0d0 + ((-0.1111111111111111d0) / x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -7.5e+28) || !(y <= 1.15e+56)) {
tmp = 1.0 - ((y / Math.sqrt(x)) * 0.3333333333333333);
} else {
tmp = 1.0 + (-0.1111111111111111 / x);
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -7.5e+28) or not (y <= 1.15e+56): tmp = 1.0 - ((y / math.sqrt(x)) * 0.3333333333333333) else: tmp = 1.0 + (-0.1111111111111111 / x) return tmp
function code(x, y) tmp = 0.0 if ((y <= -7.5e+28) || !(y <= 1.15e+56)) tmp = Float64(1.0 - Float64(Float64(y / sqrt(x)) * 0.3333333333333333)); else tmp = Float64(1.0 + Float64(-0.1111111111111111 / x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -7.5e+28) || ~((y <= 1.15e+56))) tmp = 1.0 - ((y / sqrt(x)) * 0.3333333333333333); else tmp = 1.0 + (-0.1111111111111111 / x); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -7.5e+28], N[Not[LessEqual[y, 1.15e+56]], $MachinePrecision]], N[(1.0 - N[(N[(y / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(-0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -7.5 \cdot 10^{+28} \lor \neg \left(y \leq 1.15 \cdot 10^{+56}\right):\\
\;\;\;\;1 - \frac{y}{\sqrt{x}} \cdot 0.3333333333333333\\
\mathbf{else}:\\
\;\;\;\;1 + \frac{-0.1111111111111111}{x}\\
\end{array}
\end{array}
if y < -7.4999999999999998e28 or 1.15000000000000007e56 < y Initial program 99.4%
*-commutative99.4%
associate-/r*99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in x around inf 93.9%
expm1-log1p-u50.6%
expm1-udef50.6%
associate-/r*50.6%
div-inv50.6%
metadata-eval50.6%
Applied egg-rr50.6%
expm1-def50.6%
expm1-log1p94.0%
associate-*l/94.0%
*-commutative94.0%
Simplified94.0%
if -7.4999999999999998e28 < y < 1.15000000000000007e56Initial program 99.8%
associate--l-99.8%
sub-neg99.8%
+-commutative99.8%
distribute-neg-in99.8%
distribute-neg-frac99.8%
neg-mul-199.8%
*-commutative99.8%
associate-*r/99.8%
fma-def99.8%
associate-/r*99.8%
metadata-eval99.8%
*-commutative99.8%
associate-/r*99.7%
distribute-neg-frac99.7%
metadata-eval99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in y around 0 99.0%
Final simplification96.5%
(FPCore (x y) :precision binary64 (if (or (<= y -5.5e+28) (not (<= y 2.4e+56))) (- 1.0 (/ y (sqrt (* x 9.0)))) (+ 1.0 (/ -0.1111111111111111 x))))
double code(double x, double y) {
double tmp;
if ((y <= -5.5e+28) || !(y <= 2.4e+56)) {
tmp = 1.0 - (y / sqrt((x * 9.0)));
} else {
tmp = 1.0 + (-0.1111111111111111 / x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-5.5d+28)) .or. (.not. (y <= 2.4d+56))) then
tmp = 1.0d0 - (y / sqrt((x * 9.0d0)))
else
tmp = 1.0d0 + ((-0.1111111111111111d0) / x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -5.5e+28) || !(y <= 2.4e+56)) {
tmp = 1.0 - (y / Math.sqrt((x * 9.0)));
} else {
tmp = 1.0 + (-0.1111111111111111 / x);
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -5.5e+28) or not (y <= 2.4e+56): tmp = 1.0 - (y / math.sqrt((x * 9.0))) else: tmp = 1.0 + (-0.1111111111111111 / x) return tmp
function code(x, y) tmp = 0.0 if ((y <= -5.5e+28) || !(y <= 2.4e+56)) tmp = Float64(1.0 - Float64(y / sqrt(Float64(x * 9.0)))); else tmp = Float64(1.0 + Float64(-0.1111111111111111 / x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -5.5e+28) || ~((y <= 2.4e+56))) tmp = 1.0 - (y / sqrt((x * 9.0))); else tmp = 1.0 + (-0.1111111111111111 / x); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -5.5e+28], N[Not[LessEqual[y, 2.4e+56]], $MachinePrecision]], N[(1.0 - N[(y / N[Sqrt[N[(x * 9.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(-0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.5 \cdot 10^{+28} \lor \neg \left(y \leq 2.4 \cdot 10^{+56}\right):\\
\;\;\;\;1 - \frac{y}{\sqrt{x \cdot 9}}\\
\mathbf{else}:\\
\;\;\;\;1 + \frac{-0.1111111111111111}{x}\\
\end{array}
\end{array}
if y < -5.5000000000000003e28 or 2.40000000000000013e56 < y Initial program 99.4%
*-commutative99.4%
associate-/r*99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in x around inf 93.9%
*-commutative93.9%
metadata-eval93.9%
sqrt-prod94.0%
pow1/294.0%
Applied egg-rr94.0%
unpow1/294.0%
Simplified94.0%
if -5.5000000000000003e28 < y < 2.40000000000000013e56Initial program 99.8%
associate--l-99.8%
sub-neg99.8%
+-commutative99.8%
distribute-neg-in99.8%
distribute-neg-frac99.8%
neg-mul-199.8%
*-commutative99.8%
associate-*r/99.8%
fma-def99.8%
associate-/r*99.8%
metadata-eval99.8%
*-commutative99.8%
associate-/r*99.7%
distribute-neg-frac99.7%
metadata-eval99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in y around 0 99.0%
Final simplification96.5%
(FPCore (x y)
:precision binary64
(if (<= y -6.8e+28)
(- 1.0 (* (/ y (sqrt x)) 0.3333333333333333))
(if (<= y 1.15e+56)
(+ 1.0 (/ -0.1111111111111111 x))
(- 1.0 (* y (/ 0.3333333333333333 (sqrt x)))))))
double code(double x, double y) {
double tmp;
if (y <= -6.8e+28) {
tmp = 1.0 - ((y / sqrt(x)) * 0.3333333333333333);
} else if (y <= 1.15e+56) {
tmp = 1.0 + (-0.1111111111111111 / x);
} else {
tmp = 1.0 - (y * (0.3333333333333333 / sqrt(x)));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= (-6.8d+28)) then
tmp = 1.0d0 - ((y / sqrt(x)) * 0.3333333333333333d0)
else if (y <= 1.15d+56) then
tmp = 1.0d0 + ((-0.1111111111111111d0) / x)
else
tmp = 1.0d0 - (y * (0.3333333333333333d0 / sqrt(x)))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -6.8e+28) {
tmp = 1.0 - ((y / Math.sqrt(x)) * 0.3333333333333333);
} else if (y <= 1.15e+56) {
tmp = 1.0 + (-0.1111111111111111 / x);
} else {
tmp = 1.0 - (y * (0.3333333333333333 / Math.sqrt(x)));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -6.8e+28: tmp = 1.0 - ((y / math.sqrt(x)) * 0.3333333333333333) elif y <= 1.15e+56: tmp = 1.0 + (-0.1111111111111111 / x) else: tmp = 1.0 - (y * (0.3333333333333333 / math.sqrt(x))) return tmp
function code(x, y) tmp = 0.0 if (y <= -6.8e+28) tmp = Float64(1.0 - Float64(Float64(y / sqrt(x)) * 0.3333333333333333)); elseif (y <= 1.15e+56) tmp = Float64(1.0 + Float64(-0.1111111111111111 / x)); else tmp = Float64(1.0 - Float64(y * Float64(0.3333333333333333 / sqrt(x)))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -6.8e+28) tmp = 1.0 - ((y / sqrt(x)) * 0.3333333333333333); elseif (y <= 1.15e+56) tmp = 1.0 + (-0.1111111111111111 / x); else tmp = 1.0 - (y * (0.3333333333333333 / sqrt(x))); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -6.8e+28], N[(1.0 - N[(N[(y / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.15e+56], N[(1.0 + N[(-0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision], N[(1.0 - N[(y * N[(0.3333333333333333 / N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.8 \cdot 10^{+28}:\\
\;\;\;\;1 - \frac{y}{\sqrt{x}} \cdot 0.3333333333333333\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{+56}:\\
\;\;\;\;1 + \frac{-0.1111111111111111}{x}\\
\mathbf{else}:\\
\;\;\;\;1 - y \cdot \frac{0.3333333333333333}{\sqrt{x}}\\
\end{array}
\end{array}
if y < -6.8e28Initial program 99.4%
*-commutative99.4%
associate-/r*99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in x around inf 92.1%
expm1-log1p-u10.9%
expm1-udef10.9%
associate-/r*10.9%
div-inv10.9%
metadata-eval10.9%
Applied egg-rr10.9%
expm1-def10.9%
expm1-log1p92.1%
associate-*l/92.2%
*-commutative92.2%
Simplified92.2%
if -6.8e28 < y < 1.15000000000000007e56Initial program 99.8%
associate--l-99.8%
sub-neg99.8%
+-commutative99.8%
distribute-neg-in99.8%
distribute-neg-frac99.8%
neg-mul-199.8%
*-commutative99.8%
associate-*r/99.8%
fma-def99.8%
associate-/r*99.8%
metadata-eval99.8%
*-commutative99.8%
associate-/r*99.7%
distribute-neg-frac99.7%
metadata-eval99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in y around 0 99.0%
if 1.15000000000000007e56 < y Initial program 99.3%
*-commutative99.3%
associate-/r*99.3%
metadata-eval99.3%
Simplified99.3%
Taylor expanded in x around inf 95.7%
div-inv95.8%
*-commutative95.8%
associate-/r*95.8%
metadata-eval95.8%
Applied egg-rr95.8%
Final simplification96.5%
(FPCore (x y) :precision binary64 (+ 1.0 (+ (/ -0.1111111111111111 x) (* -0.3333333333333333 (/ y (sqrt x))))))
double code(double x, double y) {
return 1.0 + ((-0.1111111111111111 / x) + (-0.3333333333333333 * (y / sqrt(x))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + (((-0.1111111111111111d0) / x) + ((-0.3333333333333333d0) * (y / sqrt(x))))
end function
public static double code(double x, double y) {
return 1.0 + ((-0.1111111111111111 / x) + (-0.3333333333333333 * (y / Math.sqrt(x))));
}
def code(x, y): return 1.0 + ((-0.1111111111111111 / x) + (-0.3333333333333333 * (y / math.sqrt(x))))
function code(x, y) return Float64(1.0 + Float64(Float64(-0.1111111111111111 / x) + Float64(-0.3333333333333333 * Float64(y / sqrt(x))))) end
function tmp = code(x, y) tmp = 1.0 + ((-0.1111111111111111 / x) + (-0.3333333333333333 * (y / sqrt(x)))); end
code[x_, y_] := N[(1.0 + N[(N[(-0.1111111111111111 / x), $MachinePrecision] + N[(-0.3333333333333333 * N[(y / N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(\frac{-0.1111111111111111}{x} + -0.3333333333333333 \cdot \frac{y}{\sqrt{x}}\right)
\end{array}
Initial program 99.6%
associate--l-99.6%
sub-neg99.6%
+-commutative99.6%
distribute-neg-in99.6%
distribute-neg-frac99.6%
neg-mul-199.6%
*-commutative99.6%
associate-*r/99.6%
fma-def99.6%
associate-/r*99.5%
metadata-eval99.5%
*-commutative99.5%
associate-/r*99.5%
distribute-neg-frac99.5%
metadata-eval99.5%
metadata-eval99.5%
Simplified99.5%
fma-udef99.5%
+-commutative99.5%
associate-*r/99.6%
associate-*l/99.6%
*-commutative99.6%
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (x y) :precision binary64 (- 1.0 (+ (/ (/ y 3.0) (sqrt x)) (/ 0.1111111111111111 x))))
double code(double x, double y) {
return 1.0 - (((y / 3.0) / sqrt(x)) + (0.1111111111111111 / x));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 - (((y / 3.0d0) / sqrt(x)) + (0.1111111111111111d0 / x))
end function
public static double code(double x, double y) {
return 1.0 - (((y / 3.0) / Math.sqrt(x)) + (0.1111111111111111 / x));
}
def code(x, y): return 1.0 - (((y / 3.0) / math.sqrt(x)) + (0.1111111111111111 / x))
function code(x, y) return Float64(1.0 - Float64(Float64(Float64(y / 3.0) / sqrt(x)) + Float64(0.1111111111111111 / x))) end
function tmp = code(x, y) tmp = 1.0 - (((y / 3.0) / sqrt(x)) + (0.1111111111111111 / x)); end
code[x_, y_] := N[(1.0 - N[(N[(N[(y / 3.0), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \left(\frac{\frac{y}{3}}{\sqrt{x}} + \frac{0.1111111111111111}{x}\right)
\end{array}
Initial program 99.6%
associate--l-99.6%
+-commutative99.6%
+-commutative99.6%
associate-/r*99.6%
Simplified99.6%
Taylor expanded in x around 0 99.6%
Final simplification99.6%
(FPCore (x y)
:precision binary64
(if (<= y -7e+127)
(/
(- 1.0 (/ 0.012345679012345678 (* x x)))
(- 1.0 (/ 0.1111111111111111 x)))
(+ 1.0 (/ -0.1111111111111111 x))))
double code(double x, double y) {
double tmp;
if (y <= -7e+127) {
tmp = (1.0 - (0.012345679012345678 / (x * x))) / (1.0 - (0.1111111111111111 / x));
} else {
tmp = 1.0 + (-0.1111111111111111 / x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= (-7d+127)) then
tmp = (1.0d0 - (0.012345679012345678d0 / (x * x))) / (1.0d0 - (0.1111111111111111d0 / x))
else
tmp = 1.0d0 + ((-0.1111111111111111d0) / x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -7e+127) {
tmp = (1.0 - (0.012345679012345678 / (x * x))) / (1.0 - (0.1111111111111111 / x));
} else {
tmp = 1.0 + (-0.1111111111111111 / x);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -7e+127: tmp = (1.0 - (0.012345679012345678 / (x * x))) / (1.0 - (0.1111111111111111 / x)) else: tmp = 1.0 + (-0.1111111111111111 / x) return tmp
function code(x, y) tmp = 0.0 if (y <= -7e+127) tmp = Float64(Float64(1.0 - Float64(0.012345679012345678 / Float64(x * x))) / Float64(1.0 - Float64(0.1111111111111111 / x))); else tmp = Float64(1.0 + Float64(-0.1111111111111111 / x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -7e+127) tmp = (1.0 - (0.012345679012345678 / (x * x))) / (1.0 - (0.1111111111111111 / x)); else tmp = 1.0 + (-0.1111111111111111 / x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -7e+127], N[(N[(1.0 - N[(0.012345679012345678 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(-0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -7 \cdot 10^{+127}:\\
\;\;\;\;\frac{1 - \frac{0.012345679012345678}{x \cdot x}}{1 - \frac{0.1111111111111111}{x}}\\
\mathbf{else}:\\
\;\;\;\;1 + \frac{-0.1111111111111111}{x}\\
\end{array}
\end{array}
if y < -6.99999999999999956e127Initial program 99.3%
associate--l-99.3%
sub-neg99.3%
+-commutative99.3%
distribute-neg-in99.3%
distribute-neg-frac99.3%
neg-mul-199.3%
*-commutative99.3%
associate-*r/99.4%
fma-def99.4%
associate-/r*99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.3%
distribute-neg-frac99.3%
metadata-eval99.3%
metadata-eval99.3%
Simplified99.3%
Taylor expanded in y around 0 3.5%
flip-+3.4%
metadata-eval3.4%
frac-times3.4%
metadata-eval3.4%
add-sqr-sqrt0.0%
sqrt-unprod4.3%
frac-times4.3%
metadata-eval4.3%
metadata-eval4.3%
frac-times4.3%
sqrt-unprod15.5%
add-sqr-sqrt15.5%
Applied egg-rr15.5%
if -6.99999999999999956e127 < y Initial program 99.6%
associate--l-99.6%
sub-neg99.6%
+-commutative99.6%
distribute-neg-in99.6%
distribute-neg-frac99.6%
neg-mul-199.6%
*-commutative99.6%
associate-*r/99.6%
fma-def99.6%
associate-/r*99.6%
metadata-eval99.6%
*-commutative99.6%
associate-/r*99.6%
distribute-neg-frac99.6%
metadata-eval99.6%
metadata-eval99.6%
Simplified99.6%
Taylor expanded in y around 0 65.4%
Final simplification57.6%
(FPCore (x y) :precision binary64 (if (<= x 0.155) (/ -0.1111111111111111 x) 1.0))
double code(double x, double y) {
double tmp;
if (x <= 0.155) {
tmp = -0.1111111111111111 / x;
} else {
tmp = 1.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= 0.155d0) then
tmp = (-0.1111111111111111d0) / x
else
tmp = 1.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= 0.155) {
tmp = -0.1111111111111111 / x;
} else {
tmp = 1.0;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= 0.155: tmp = -0.1111111111111111 / x else: tmp = 1.0 return tmp
function code(x, y) tmp = 0.0 if (x <= 0.155) tmp = Float64(-0.1111111111111111 / x); else tmp = 1.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= 0.155) tmp = -0.1111111111111111 / x; else tmp = 1.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, 0.155], N[(-0.1111111111111111 / x), $MachinePrecision], 1.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.155:\\
\;\;\;\;\frac{-0.1111111111111111}{x}\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if x < 0.154999999999999999Initial program 99.4%
associate--l-99.4%
sub-neg99.4%
+-commutative99.4%
distribute-neg-in99.4%
distribute-neg-frac99.4%
neg-mul-199.4%
*-commutative99.4%
associate-*r/99.5%
fma-def99.5%
associate-/r*99.4%
metadata-eval99.4%
*-commutative99.4%
associate-/r*99.4%
distribute-neg-frac99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in y around 0 55.1%
Taylor expanded in x around 0 54.3%
if 0.154999999999999999 < x Initial program 99.7%
associate--l-99.7%
sub-neg99.7%
+-commutative99.7%
distribute-neg-in99.7%
distribute-neg-frac99.7%
neg-mul-199.7%
*-commutative99.7%
associate-*r/99.6%
fma-def99.6%
associate-/r*99.6%
metadata-eval99.6%
*-commutative99.6%
associate-/r*99.6%
distribute-neg-frac99.6%
metadata-eval99.6%
metadata-eval99.6%
Simplified99.6%
Taylor expanded in y around 0 56.3%
Taylor expanded in x around inf 56.2%
Final simplification55.3%
(FPCore (x y) :precision binary64 (+ 1.0 (/ -0.1111111111111111 x)))
double code(double x, double y) {
return 1.0 + (-0.1111111111111111 / x);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + ((-0.1111111111111111d0) / x)
end function
public static double code(double x, double y) {
return 1.0 + (-0.1111111111111111 / x);
}
def code(x, y): return 1.0 + (-0.1111111111111111 / x)
function code(x, y) return Float64(1.0 + Float64(-0.1111111111111111 / x)) end
function tmp = code(x, y) tmp = 1.0 + (-0.1111111111111111 / x); end
code[x_, y_] := N[(1.0 + N[(-0.1111111111111111 / x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{-0.1111111111111111}{x}
\end{array}
Initial program 99.6%
associate--l-99.6%
sub-neg99.6%
+-commutative99.6%
distribute-neg-in99.6%
distribute-neg-frac99.6%
neg-mul-199.6%
*-commutative99.6%
associate-*r/99.6%
fma-def99.6%
associate-/r*99.5%
metadata-eval99.5%
*-commutative99.5%
associate-/r*99.5%
distribute-neg-frac99.5%
metadata-eval99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in y around 0 55.7%
Final simplification55.7%
(FPCore (x y) :precision binary64 1.0)
double code(double x, double y) {
return 1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0
end function
public static double code(double x, double y) {
return 1.0;
}
def code(x, y): return 1.0
function code(x, y) return 1.0 end
function tmp = code(x, y) tmp = 1.0; end
code[x_, y_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 99.6%
associate--l-99.6%
sub-neg99.6%
+-commutative99.6%
distribute-neg-in99.6%
distribute-neg-frac99.6%
neg-mul-199.6%
*-commutative99.6%
associate-*r/99.6%
fma-def99.6%
associate-/r*99.5%
metadata-eval99.5%
*-commutative99.5%
associate-/r*99.5%
distribute-neg-frac99.5%
metadata-eval99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in y around 0 55.7%
Taylor expanded in x around inf 30.1%
Final simplification30.1%
(FPCore (x y) :precision binary64 (- (- 1.0 (/ (/ 1.0 x) 9.0)) (/ y (* 3.0 (sqrt x)))))
double code(double x, double y) {
return (1.0 - ((1.0 / x) / 9.0)) - (y / (3.0 * sqrt(x)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (1.0d0 - ((1.0d0 / x) / 9.0d0)) - (y / (3.0d0 * sqrt(x)))
end function
public static double code(double x, double y) {
return (1.0 - ((1.0 / x) / 9.0)) - (y / (3.0 * Math.sqrt(x)));
}
def code(x, y): return (1.0 - ((1.0 / x) / 9.0)) - (y / (3.0 * math.sqrt(x)))
function code(x, y) return Float64(Float64(1.0 - Float64(Float64(1.0 / x) / 9.0)) - Float64(y / Float64(3.0 * sqrt(x)))) end
function tmp = code(x, y) tmp = (1.0 - ((1.0 / x) / 9.0)) - (y / (3.0 * sqrt(x))); end
code[x_, y_] := N[(N[(1.0 - N[(N[(1.0 / x), $MachinePrecision] / 9.0), $MachinePrecision]), $MachinePrecision] - N[(y / N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(1 - \frac{\frac{1}{x}}{9}\right) - \frac{y}{3 \cdot \sqrt{x}}
\end{array}
herbie shell --seed 2023196
(FPCore (x y)
:name "Numeric.SpecFunctions:invIncompleteGamma from math-functions-0.1.5.2, D"
:precision binary64
:herbie-target
(- (- 1.0 (/ (/ 1.0 x) 9.0)) (/ y (* 3.0 (sqrt x))))
(- (- 1.0 (/ 1.0 (* x 9.0))) (/ y (* 3.0 (sqrt x)))))