
(FPCore (x y) :precision binary64 (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))
double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function
public static double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
def code(x, y): return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))
function code(x, y) return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0))) end
function tmp = code(x, y) tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0)); end
code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))
double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function
public static double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
def code(x, y): return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))
function code(x, y) return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0))) end
function tmp = code(x, y) tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0)); end
code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)}
\end{array}
(FPCore (x y) :precision binary64 (/ (* (/ y (+ (+ y x) 1.0)) (/ x (+ y x))) (+ y x)))
double code(double x, double y) {
return ((y / ((y + x) + 1.0)) * (x / (y + x))) / (y + x);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((y / ((y + x) + 1.0d0)) * (x / (y + x))) / (y + x)
end function
public static double code(double x, double y) {
return ((y / ((y + x) + 1.0)) * (x / (y + x))) / (y + x);
}
def code(x, y): return ((y / ((y + x) + 1.0)) * (x / (y + x))) / (y + x)
function code(x, y) return Float64(Float64(Float64(y / Float64(Float64(y + x) + 1.0)) * Float64(x / Float64(y + x))) / Float64(y + x)) end
function tmp = code(x, y) tmp = ((y / ((y + x) + 1.0)) * (x / (y + x))) / (y + x); end
code[x_, y_] := N[(N[(N[(y / N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] * N[(x / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{y}{\left(y + x\right) + 1} \cdot \frac{x}{y + x}}{y + x}
\end{array}
Initial program 70.3%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (x y) :precision binary64 (if (<= y 7.6e+151) (/ (* x (/ y (+ y x))) (* (+ y x) (+ (+ y x) 1.0))) (/ (/ x (+ y x)) (+ y (fma x (+ 2.0 (/ 1.0 y)) 1.0)))))
double code(double x, double y) {
double tmp;
if (y <= 7.6e+151) {
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / (y + x)) / (y + fma(x, (2.0 + (1.0 / y)), 1.0));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 7.6e+151) tmp = Float64(Float64(x * Float64(y / Float64(y + x))) / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); else tmp = Float64(Float64(x / Float64(y + x)) / Float64(y + fma(x, Float64(2.0 + Float64(1.0 / y)), 1.0))); end return tmp end
code[x_, y_] := If[LessEqual[y, 7.6e+151], N[(N[(x * N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x * N[(2.0 + N[(1.0 / y), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 7.6 \cdot 10^{+151}:\\
\;\;\;\;\frac{x \cdot \frac{y}{y + x}}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + x}}{y + \mathsf{fma}\left(x, 2 + \frac{1}{y}, 1\right)}\\
\end{array}
\end{array}
if y < 7.6000000000000001e151Initial program 71.5%
*-commutativeN/A
associate-*l*N/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6497.5
Applied egg-rr97.5%
if 7.6000000000000001e151 < y Initial program 60.2%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64100.0
Applied egg-rr100.0%
associate-/l*N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64100.0
Applied egg-rr100.0%
Taylor expanded in x around 0
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
accelerator-lowering-fma.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6490.3
Simplified90.3%
Final simplification96.7%
(FPCore (x y)
:precision binary64
(if (<= x -1.2e-12)
(/ (* x (/ y (* (+ y x) (+ y x)))) (+ (+ y x) 1.0))
(if (<= x 2.4e-32)
(/ (* x (/ y (+ y x))) (* (+ y x) (+ y 1.0)))
(/ (/ x y) (+ y x)))))
double code(double x, double y) {
double tmp;
if (x <= -1.2e-12) {
tmp = (x * (y / ((y + x) * (y + x)))) / ((y + x) + 1.0);
} else if (x <= 2.4e-32) {
tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.2d-12)) then
tmp = (x * (y / ((y + x) * (y + x)))) / ((y + x) + 1.0d0)
else if (x <= 2.4d-32) then
tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0d0))
else
tmp = (x / y) / (y + x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -1.2e-12) {
tmp = (x * (y / ((y + x) * (y + x)))) / ((y + x) + 1.0);
} else if (x <= 2.4e-32) {
tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.2e-12: tmp = (x * (y / ((y + x) * (y + x)))) / ((y + x) + 1.0) elif x <= 2.4e-32: tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0)) else: tmp = (x / y) / (y + x) return tmp
function code(x, y) tmp = 0.0 if (x <= -1.2e-12) tmp = Float64(Float64(x * Float64(y / Float64(Float64(y + x) * Float64(y + x)))) / Float64(Float64(y + x) + 1.0)); elseif (x <= 2.4e-32) tmp = Float64(Float64(x * Float64(y / Float64(y + x))) / Float64(Float64(y + x) * Float64(y + 1.0))); else tmp = Float64(Float64(x / y) / Float64(y + x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -1.2e-12) tmp = (x * (y / ((y + x) * (y + x)))) / ((y + x) + 1.0); elseif (x <= 2.4e-32) tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0)); else tmp = (x / y) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.2e-12], N[(N[(x * N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.4e-32], N[(N[(x * N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.2 \cdot 10^{-12}:\\
\;\;\;\;\frac{x \cdot \frac{y}{\left(y + x\right) \cdot \left(y + x\right)}}{\left(y + x\right) + 1}\\
\mathbf{elif}\;x \leq 2.4 \cdot 10^{-32}:\\
\;\;\;\;\frac{x \cdot \frac{y}{y + x}}{\left(y + x\right) \cdot \left(y + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y + x}\\
\end{array}
\end{array}
if x < -1.19999999999999994e-12Initial program 69.2%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6495.8
Applied egg-rr95.8%
if -1.19999999999999994e-12 < x < 2.4000000000000001e-32Initial program 72.6%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
associate-/l*N/A
associate-/r*N/A
times-fracN/A
*-commutativeN/A
frac-timesN/A
associate-/r*N/A
frac-timesN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
Taylor expanded in y around inf
Simplified99.9%
if 2.4000000000000001e-32 < x Initial program 67.5%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
Taylor expanded in y around inf
/-lowering-/.f6428.1
Simplified28.1%
Final simplification78.1%
(FPCore (x y)
:precision binary64
(if (<= x -1.2e-9)
(/ y (* (+ y x) (+ x (+ y 1.0))))
(if (<= x 2.4e-32)
(/ (* x (/ y (+ y x))) (* (+ y x) (+ y 1.0)))
(/ (/ x y) (+ y x)))))
double code(double x, double y) {
double tmp;
if (x <= -1.2e-9) {
tmp = y / ((y + x) * (x + (y + 1.0)));
} else if (x <= 2.4e-32) {
tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.2d-9)) then
tmp = y / ((y + x) * (x + (y + 1.0d0)))
else if (x <= 2.4d-32) then
tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0d0))
else
tmp = (x / y) / (y + x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -1.2e-9) {
tmp = y / ((y + x) * (x + (y + 1.0)));
} else if (x <= 2.4e-32) {
tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.2e-9: tmp = y / ((y + x) * (x + (y + 1.0))) elif x <= 2.4e-32: tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0)) else: tmp = (x / y) / (y + x) return tmp
function code(x, y) tmp = 0.0 if (x <= -1.2e-9) tmp = Float64(y / Float64(Float64(y + x) * Float64(x + Float64(y + 1.0)))); elseif (x <= 2.4e-32) tmp = Float64(Float64(x * Float64(y / Float64(y + x))) / Float64(Float64(y + x) * Float64(y + 1.0))); else tmp = Float64(Float64(x / y) / Float64(y + x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -1.2e-9) tmp = y / ((y + x) * (x + (y + 1.0))); elseif (x <= 2.4e-32) tmp = (x * (y / (y + x))) / ((y + x) * (y + 1.0)); else tmp = (x / y) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.2e-9], N[(y / N[(N[(y + x), $MachinePrecision] * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.4e-32], N[(N[(x * N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.2 \cdot 10^{-9}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{elif}\;x \leq 2.4 \cdot 10^{-32}:\\
\;\;\;\;\frac{x \cdot \frac{y}{y + x}}{\left(y + x\right) \cdot \left(y + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y + x}\\
\end{array}
\end{array}
if x < -1.2e-9Initial program 69.2%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
Taylor expanded in x around inf
Simplified79.3%
+-commutativeN/A
*-rgt-identityN/A
associate-/l/N/A
*-commutativeN/A
+-commutativeN/A
/-lowering-/.f64N/A
+-commutativeN/A
*-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6490.3
Applied egg-rr90.3%
if -1.2e-9 < x < 2.4000000000000001e-32Initial program 72.6%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
associate-/l*N/A
associate-/r*N/A
times-fracN/A
*-commutativeN/A
frac-timesN/A
associate-/r*N/A
frac-timesN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
Taylor expanded in y around inf
Simplified99.9%
if 2.4000000000000001e-32 < x Initial program 67.5%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
Taylor expanded in y around inf
/-lowering-/.f6428.1
Simplified28.1%
Final simplification76.6%
(FPCore (x y)
:precision binary64
(if (<= y 1.8e-167)
(/ y (* x (+ x (+ y 1.0))))
(if (<= y 4e+124)
(* x (/ y (* (+ (+ y x) 1.0) (* (+ y x) (+ y x)))))
(/ (/ x (+ y 1.0)) (+ y x)))))
double code(double x, double y) {
double tmp;
if (y <= 1.8e-167) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 4e+124) {
tmp = x * (y / (((y + x) + 1.0) * ((y + x) * (y + x))));
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 1.8d-167) then
tmp = y / (x * (x + (y + 1.0d0)))
else if (y <= 4d+124) then
tmp = x * (y / (((y + x) + 1.0d0) * ((y + x) * (y + x))))
else
tmp = (x / (y + 1.0d0)) / (y + x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 1.8e-167) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 4e+124) {
tmp = x * (y / (((y + x) + 1.0) * ((y + x) * (y + x))));
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 1.8e-167: tmp = y / (x * (x + (y + 1.0))) elif y <= 4e+124: tmp = x * (y / (((y + x) + 1.0) * ((y + x) * (y + x)))) else: tmp = (x / (y + 1.0)) / (y + x) return tmp
function code(x, y) tmp = 0.0 if (y <= 1.8e-167) tmp = Float64(y / Float64(x * Float64(x + Float64(y + 1.0)))); elseif (y <= 4e+124) tmp = Float64(x * Float64(y / Float64(Float64(Float64(y + x) + 1.0) * Float64(Float64(y + x) * Float64(y + x))))); else tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 1.8e-167) tmp = y / (x * (x + (y + 1.0))); elseif (y <= 4e+124) tmp = x * (y / (((y + x) + 1.0) * ((y + x) * (y + x)))); else tmp = (x / (y + 1.0)) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 1.8e-167], N[(y / N[(x * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4e+124], N[(x * N[(y / N[(N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.8 \cdot 10^{-167}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{elif}\;y \leq 4 \cdot 10^{+124}:\\
\;\;\;\;x \cdot \frac{y}{\left(\left(y + x\right) + 1\right) \cdot \left(\left(y + x\right) \cdot \left(y + x\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\
\end{array}
\end{array}
if y < 1.8e-167Initial program 68.7%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6488.3
Applied egg-rr88.3%
Taylor expanded in y around 0
/-lowering-/.f6457.9
Simplified57.9%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6462.5
Applied egg-rr62.5%
if 1.8e-167 < y < 3.99999999999999979e124Initial program 82.5%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6489.7
Applied egg-rr89.7%
if 3.99999999999999979e124 < y Initial program 57.2%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64100.0
Applied egg-rr100.0%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6484.6
Simplified84.6%
Final simplification73.1%
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ (+ y x) 1.0)))
(if (<= y 1.9e-167)
(/ y (* x (+ x (+ y 1.0))))
(if (<= y 4.7e+32)
(* y (/ x (* t_0 (* (+ y x) (+ y x)))))
(if (<= y 4.1e+155)
(/ x (* (+ y x) t_0))
(/ (/ x (+ y 1.0)) (+ y x)))))))
double code(double x, double y) {
double t_0 = (y + x) + 1.0;
double tmp;
if (y <= 1.9e-167) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 4.7e+32) {
tmp = y * (x / (t_0 * ((y + x) * (y + x))));
} else if (y <= 4.1e+155) {
tmp = x / ((y + x) * t_0);
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = (y + x) + 1.0d0
if (y <= 1.9d-167) then
tmp = y / (x * (x + (y + 1.0d0)))
else if (y <= 4.7d+32) then
tmp = y * (x / (t_0 * ((y + x) * (y + x))))
else if (y <= 4.1d+155) then
tmp = x / ((y + x) * t_0)
else
tmp = (x / (y + 1.0d0)) / (y + x)
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = (y + x) + 1.0;
double tmp;
if (y <= 1.9e-167) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 4.7e+32) {
tmp = y * (x / (t_0 * ((y + x) * (y + x))));
} else if (y <= 4.1e+155) {
tmp = x / ((y + x) * t_0);
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
def code(x, y): t_0 = (y + x) + 1.0 tmp = 0 if y <= 1.9e-167: tmp = y / (x * (x + (y + 1.0))) elif y <= 4.7e+32: tmp = y * (x / (t_0 * ((y + x) * (y + x)))) elif y <= 4.1e+155: tmp = x / ((y + x) * t_0) else: tmp = (x / (y + 1.0)) / (y + x) return tmp
function code(x, y) t_0 = Float64(Float64(y + x) + 1.0) tmp = 0.0 if (y <= 1.9e-167) tmp = Float64(y / Float64(x * Float64(x + Float64(y + 1.0)))); elseif (y <= 4.7e+32) tmp = Float64(y * Float64(x / Float64(t_0 * Float64(Float64(y + x) * Float64(y + x))))); elseif (y <= 4.1e+155) tmp = Float64(x / Float64(Float64(y + x) * t_0)); else tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x)); end return tmp end
function tmp_2 = code(x, y) t_0 = (y + x) + 1.0; tmp = 0.0; if (y <= 1.9e-167) tmp = y / (x * (x + (y + 1.0))); elseif (y <= 4.7e+32) tmp = y * (x / (t_0 * ((y + x) * (y + x)))); elseif (y <= 4.1e+155) tmp = x / ((y + x) * t_0); else tmp = (x / (y + 1.0)) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]}, If[LessEqual[y, 1.9e-167], N[(y / N[(x * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.7e+32], N[(y * N[(x / N[(t$95$0 * N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.1e+155], N[(x / N[(N[(y + x), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(y + x\right) + 1\\
\mathbf{if}\;y \leq 1.9 \cdot 10^{-167}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{elif}\;y \leq 4.7 \cdot 10^{+32}:\\
\;\;\;\;y \cdot \frac{x}{t\_0 \cdot \left(\left(y + x\right) \cdot \left(y + x\right)\right)}\\
\mathbf{elif}\;y \leq 4.1 \cdot 10^{+155}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\
\end{array}
\end{array}
if y < 1.89999999999999984e-167Initial program 68.7%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6488.3
Applied egg-rr88.3%
Taylor expanded in y around 0
/-lowering-/.f6457.9
Simplified57.9%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6462.5
Applied egg-rr62.5%
if 1.89999999999999984e-167 < y < 4.70000000000000023e32Initial program 89.0%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6494.5
Applied egg-rr94.5%
if 4.70000000000000023e32 < y < 4.0999999999999998e155Initial program 57.9%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
associate-/l*N/A
associate-/r*N/A
times-fracN/A
*-commutativeN/A
frac-timesN/A
associate-/r*N/A
frac-timesN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6492.5
Applied egg-rr92.5%
Taylor expanded in y around inf
Simplified87.5%
if 4.0999999999999998e155 < y Initial program 64.4%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64100.0
Applied egg-rr100.0%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6492.9
Simplified92.9%
Final simplification74.8%
(FPCore (x y) :precision binary64 (if (<= y 3.9e+155) (/ (* x (/ y (+ y x))) (* (+ y x) (+ (+ y x) 1.0))) (/ (/ x (+ y 1.0)) (+ y x))))
double code(double x, double y) {
double tmp;
if (y <= 3.9e+155) {
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 3.9d+155) then
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0d0))
else
tmp = (x / (y + 1.0d0)) / (y + x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 3.9e+155) {
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 3.9e+155: tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0)) else: tmp = (x / (y + 1.0)) / (y + x) return tmp
function code(x, y) tmp = 0.0 if (y <= 3.9e+155) tmp = Float64(Float64(x * Float64(y / Float64(y + x))) / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); else tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 3.9e+155) tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0)); else tmp = (x / (y + 1.0)) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 3.9e+155], N[(N[(x * N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.9 \cdot 10^{+155}:\\
\;\;\;\;\frac{x \cdot \frac{y}{y + x}}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\
\end{array}
\end{array}
if y < 3.8999999999999998e155Initial program 70.9%
*-commutativeN/A
associate-*l*N/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6497.5
Applied egg-rr97.5%
if 3.8999999999999998e155 < y Initial program 64.4%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64100.0
Applied egg-rr100.0%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6492.9
Simplified92.9%
Final simplification97.1%
(FPCore (x y)
:precision binary64
(if (<= y 7.2e-140)
(/ y (* x (+ x (+ y 1.0))))
(if (<= y 6.8e+155)
(/ x (* (+ y x) (+ (+ y x) 1.0)))
(/ (/ x (+ y 1.0)) (+ y x)))))
double code(double x, double y) {
double tmp;
if (y <= 7.2e-140) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 6.8e+155) {
tmp = x / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / (y + 1.0)) / (y + 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.2d-140) then
tmp = y / (x * (x + (y + 1.0d0)))
else if (y <= 6.8d+155) then
tmp = x / ((y + x) * ((y + x) + 1.0d0))
else
tmp = (x / (y + 1.0d0)) / (y + x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 7.2e-140) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 6.8e+155) {
tmp = x / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 7.2e-140: tmp = y / (x * (x + (y + 1.0))) elif y <= 6.8e+155: tmp = x / ((y + x) * ((y + x) + 1.0)) else: tmp = (x / (y + 1.0)) / (y + x) return tmp
function code(x, y) tmp = 0.0 if (y <= 7.2e-140) tmp = Float64(y / Float64(x * Float64(x + Float64(y + 1.0)))); elseif (y <= 6.8e+155) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); else tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 7.2e-140) tmp = y / (x * (x + (y + 1.0))); elseif (y <= 6.8e+155) tmp = x / ((y + x) * ((y + x) + 1.0)); else tmp = (x / (y + 1.0)) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 7.2e-140], N[(y / N[(x * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.8e+155], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 7.2 \cdot 10^{-140}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{elif}\;y \leq 6.8 \cdot 10^{+155}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\
\end{array}
\end{array}
if y < 7.2000000000000001e-140Initial program 68.9%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6488.2
Applied egg-rr88.2%
Taylor expanded in y around 0
/-lowering-/.f6458.4
Simplified58.4%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6462.9
Applied egg-rr62.9%
if 7.2000000000000001e-140 < y < 6.8000000000000002e155Initial program 75.0%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
associate-/l*N/A
associate-/r*N/A
times-fracN/A
*-commutativeN/A
frac-timesN/A
associate-/r*N/A
frac-timesN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6495.2
Applied egg-rr95.2%
Taylor expanded in y around inf
Simplified83.2%
if 6.8000000000000002e155 < y Initial program 64.4%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64100.0
Applied egg-rr100.0%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6492.9
Simplified92.9%
Final simplification72.1%
(FPCore (x y) :precision binary64 (if (<= y 7.8e-140) (/ y (* x (+ x (+ y 1.0)))) (if (<= y 3.5e+155) (/ x (* (+ y x) (+ (+ y x) 1.0))) (/ (/ x y) (+ y x)))))
double code(double x, double y) {
double tmp;
if (y <= 7.8e-140) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 3.5e+155) {
tmp = x / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / y) / (y + 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.8d-140) then
tmp = y / (x * (x + (y + 1.0d0)))
else if (y <= 3.5d+155) then
tmp = x / ((y + x) * ((y + x) + 1.0d0))
else
tmp = (x / y) / (y + x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 7.8e-140) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 3.5e+155) {
tmp = x / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 7.8e-140: tmp = y / (x * (x + (y + 1.0))) elif y <= 3.5e+155: tmp = x / ((y + x) * ((y + x) + 1.0)) else: tmp = (x / y) / (y + x) return tmp
function code(x, y) tmp = 0.0 if (y <= 7.8e-140) tmp = Float64(y / Float64(x * Float64(x + Float64(y + 1.0)))); elseif (y <= 3.5e+155) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); else tmp = Float64(Float64(x / y) / Float64(y + x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 7.8e-140) tmp = y / (x * (x + (y + 1.0))); elseif (y <= 3.5e+155) tmp = x / ((y + x) * ((y + x) + 1.0)); else tmp = (x / y) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 7.8e-140], N[(y / N[(x * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.5e+155], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 7.8 \cdot 10^{-140}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{elif}\;y \leq 3.5 \cdot 10^{+155}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y + x}\\
\end{array}
\end{array}
if y < 7.80000000000000038e-140Initial program 68.9%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6488.2
Applied egg-rr88.2%
Taylor expanded in y around 0
/-lowering-/.f6458.4
Simplified58.4%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6462.9
Applied egg-rr62.9%
if 7.80000000000000038e-140 < y < 3.49999999999999985e155Initial program 75.0%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
associate-/l*N/A
associate-/r*N/A
times-fracN/A
*-commutativeN/A
frac-timesN/A
associate-/r*N/A
frac-timesN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6495.2
Applied egg-rr95.2%
Taylor expanded in y around inf
Simplified83.2%
if 3.49999999999999985e155 < y Initial program 64.4%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64100.0
Applied egg-rr100.0%
Taylor expanded in y around inf
/-lowering-/.f6492.9
Simplified92.9%
Final simplification72.1%
(FPCore (x y) :precision binary64 (if (<= y 1.05e-139) (/ y (* x (+ x (+ y 1.0)))) (if (<= y 3.9e+155) (/ x (* (+ y x) (+ (+ y x) 1.0))) (/ (/ x y) y))))
double code(double x, double y) {
double tmp;
if (y <= 1.05e-139) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 3.9e+155) {
tmp = x / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / y) / y;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 1.05d-139) then
tmp = y / (x * (x + (y + 1.0d0)))
else if (y <= 3.9d+155) then
tmp = x / ((y + x) * ((y + x) + 1.0d0))
else
tmp = (x / y) / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 1.05e-139) {
tmp = y / (x * (x + (y + 1.0)));
} else if (y <= 3.9e+155) {
tmp = x / ((y + x) * ((y + x) + 1.0));
} else {
tmp = (x / y) / y;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 1.05e-139: tmp = y / (x * (x + (y + 1.0))) elif y <= 3.9e+155: tmp = x / ((y + x) * ((y + x) + 1.0)) else: tmp = (x / y) / y return tmp
function code(x, y) tmp = 0.0 if (y <= 1.05e-139) tmp = Float64(y / Float64(x * Float64(x + Float64(y + 1.0)))); elseif (y <= 3.9e+155) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); else tmp = Float64(Float64(x / y) / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 1.05e-139) tmp = y / (x * (x + (y + 1.0))); elseif (y <= 3.9e+155) tmp = x / ((y + x) * ((y + x) + 1.0)); else tmp = (x / y) / y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 1.05e-139], N[(y / N[(x * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.9e+155], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.05 \cdot 10^{-139}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{elif}\;y \leq 3.9 \cdot 10^{+155}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y}\\
\end{array}
\end{array}
if y < 1.05000000000000004e-139Initial program 68.9%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6488.2
Applied egg-rr88.2%
Taylor expanded in y around 0
/-lowering-/.f6458.4
Simplified58.4%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6462.9
Applied egg-rr62.9%
if 1.05000000000000004e-139 < y < 3.8999999999999998e155Initial program 75.0%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
associate-/l*N/A
associate-/r*N/A
times-fracN/A
*-commutativeN/A
frac-timesN/A
associate-/r*N/A
frac-timesN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6495.2
Applied egg-rr95.2%
Taylor expanded in y around inf
Simplified83.2%
if 3.8999999999999998e155 < y Initial program 64.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6480.6
Simplified80.6%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f6492.8
Applied egg-rr92.8%
(FPCore (x y) :precision binary64 (if (<= x -1.1e-31) (/ y (* x (+ x (+ y 1.0)))) (if (<= x 2.4e-32) (/ x (fma y y y)) (/ (/ x y) y))))
double code(double x, double y) {
double tmp;
if (x <= -1.1e-31) {
tmp = y / (x * (x + (y + 1.0)));
} else if (x <= 2.4e-32) {
tmp = x / fma(y, y, y);
} else {
tmp = (x / y) / y;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -1.1e-31) tmp = Float64(y / Float64(x * Float64(x + Float64(y + 1.0)))); elseif (x <= 2.4e-32) tmp = Float64(x / fma(y, y, y)); else tmp = Float64(Float64(x / y) / y); end return tmp end
code[x_, y_] := If[LessEqual[x, -1.1e-31], N[(y / N[(x * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.4e-32], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.1 \cdot 10^{-31}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{elif}\;x \leq 2.4 \cdot 10^{-32}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y}\\
\end{array}
\end{array}
if x < -1.10000000000000005e-31Initial program 69.7%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6495.9
Applied egg-rr95.9%
Taylor expanded in y around 0
/-lowering-/.f6477.2
Simplified77.2%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6484.0
Applied egg-rr84.0%
if -1.10000000000000005e-31 < x < 2.4000000000000001e-32Initial program 72.5%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6481.3
Simplified81.3%
if 2.4000000000000001e-32 < x Initial program 67.5%
Taylor expanded in y around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6426.0
Simplified26.0%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f6427.5
Applied egg-rr27.5%
(FPCore (x y) :precision binary64 (if (<= y 8e-140) (/ y (fma x x x)) (if (<= y 122000000000.0) (/ x (fma y y y)) (/ x (* y (+ y x))))))
double code(double x, double y) {
double tmp;
if (y <= 8e-140) {
tmp = y / fma(x, x, x);
} else if (y <= 122000000000.0) {
tmp = x / fma(y, y, y);
} else {
tmp = x / (y * (y + x));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 8e-140) tmp = Float64(y / fma(x, x, x)); elseif (y <= 122000000000.0) tmp = Float64(x / fma(y, y, y)); else tmp = Float64(x / Float64(y * Float64(y + x))); end return tmp end
code[x_, y_] := If[LessEqual[y, 8e-140], N[(y / N[(x * x + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 122000000000.0], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 8 \cdot 10^{-140}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(x, x, x\right)}\\
\mathbf{elif}\;y \leq 122000000000:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(y + x\right)}\\
\end{array}
\end{array}
if y < 7.9999999999999999e-140Initial program 68.9%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6458.7
Simplified58.7%
if 7.9999999999999999e-140 < y < 1.22e11Initial program 91.9%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6435.8
Simplified35.8%
if 1.22e11 < y Initial program 61.1%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
Taylor expanded in y around inf
/-lowering-/.f6475.4
Simplified75.4%
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f6480.9
Applied egg-rr80.9%
(FPCore (x y) :precision binary64 (if (<= x -1.6e-32) (/ y (* x (+ x (+ y 1.0)))) (/ x (fma y y y))))
double code(double x, double y) {
double tmp;
if (x <= -1.6e-32) {
tmp = y / (x * (x + (y + 1.0)));
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -1.6e-32) tmp = Float64(y / Float64(x * Float64(x + Float64(y + 1.0)))); else tmp = Float64(x / fma(y, y, y)); end return tmp end
code[x_, y_] := If[LessEqual[x, -1.6e-32], N[(y / N[(x * N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.6 \cdot 10^{-32}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + \left(y + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -1.6000000000000001e-32Initial program 69.7%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6495.9
Applied egg-rr95.9%
Taylor expanded in y around 0
/-lowering-/.f6477.2
Simplified77.2%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6484.0
Applied egg-rr84.0%
if -1.6000000000000001e-32 < x Initial program 70.5%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6459.2
Simplified59.2%
(FPCore (x y) :precision binary64 (if (<= x -7.5e-32) (/ y (fma x x x)) (/ x (fma y y y))))
double code(double x, double y) {
double tmp;
if (x <= -7.5e-32) {
tmp = y / fma(x, x, x);
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -7.5e-32) tmp = Float64(y / fma(x, x, x)); else tmp = Float64(x / fma(y, y, y)); end return tmp end
code[x_, y_] := If[LessEqual[x, -7.5e-32], N[(y / N[(x * x + x), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -7.5 \cdot 10^{-32}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(x, x, x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -7.49999999999999953e-32Initial program 69.7%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6478.3
Simplified78.3%
if -7.49999999999999953e-32 < x Initial program 70.5%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6459.2
Simplified59.2%
(FPCore (x y) :precision binary64 (if (<= x -7e+22) (/ y (* x x)) (/ x (fma y y y))))
double code(double x, double y) {
double tmp;
if (x <= -7e+22) {
tmp = y / (x * x);
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -7e+22) tmp = Float64(y / Float64(x * x)); else tmp = Float64(x / fma(y, y, y)); end return tmp end
code[x_, y_] := If[LessEqual[x, -7e+22], N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -7 \cdot 10^{+22}:\\
\;\;\;\;\frac{y}{x \cdot x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -7e22Initial program 67.1%
Taylor expanded in x around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6485.6
Simplified85.6%
if -7e22 < x Initial program 71.2%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6459.5
Simplified59.5%
(FPCore (x y) :precision binary64 (if (<= x -8.5e+22) (/ y (* x x)) (/ x (* y y))))
double code(double x, double y) {
double tmp;
if (x <= -8.5e+22) {
tmp = y / (x * x);
} else {
tmp = x / (y * y);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-8.5d+22)) then
tmp = y / (x * x)
else
tmp = x / (y * y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -8.5e+22) {
tmp = y / (x * x);
} else {
tmp = x / (y * y);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -8.5e+22: tmp = y / (x * x) else: tmp = x / (y * y) return tmp
function code(x, y) tmp = 0.0 if (x <= -8.5e+22) tmp = Float64(y / Float64(x * x)); else tmp = Float64(x / Float64(y * y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -8.5e+22) tmp = y / (x * x); else tmp = x / (y * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -8.5e+22], N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -8.5 \cdot 10^{+22}:\\
\;\;\;\;\frac{y}{x \cdot x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot y}\\
\end{array}
\end{array}
if x < -8.49999999999999979e22Initial program 67.1%
Taylor expanded in x around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6485.6
Simplified85.6%
if -8.49999999999999979e22 < x Initial program 71.2%
Taylor expanded in y around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6443.5
Simplified43.5%
(FPCore (x y) :precision binary64 (/ x (* y y)))
double code(double x, double y) {
return x / (y * y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x / (y * y)
end function
public static double code(double x, double y) {
return x / (y * y);
}
def code(x, y): return x / (y * y)
function code(x, y) return Float64(x / Float64(y * y)) end
function tmp = code(x, y) tmp = x / (y * y); end
code[x_, y_] := N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y \cdot y}
\end{array}
Initial program 70.3%
Taylor expanded in y around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6437.9
Simplified37.9%
(FPCore (x y) :precision binary64 (/ 1.0 (+ y x)))
double code(double x, double y) {
return 1.0 / (y + x);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 / (y + x)
end function
public static double code(double x, double y) {
return 1.0 / (y + x);
}
def code(x, y): return 1.0 / (y + x)
function code(x, y) return Float64(1.0 / Float64(y + x)) end
function tmp = code(x, y) tmp = 1.0 / (y + x); end
code[x_, y_] := N[(1.0 / N[(y + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{y + x}
\end{array}
Initial program 70.3%
times-fracN/A
*-commutativeN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9
Applied egg-rr99.9%
Taylor expanded in x around inf
Simplified52.7%
Taylor expanded in y around inf
Simplified5.3%
Final simplification5.3%
(FPCore (x y) :precision binary64 (/ 1.0 x))
double code(double x, double y) {
return 1.0 / x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 / x
end function
public static double code(double x, double y) {
return 1.0 / x;
}
def code(x, y): return 1.0 / x
function code(x, y) return Float64(1.0 / x) end
function tmp = code(x, y) tmp = 1.0 / x; end
code[x_, y_] := N[(1.0 / x), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{x}
\end{array}
Initial program 70.3%
*-commutativeN/A
times-fracN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6489.5
Applied egg-rr89.5%
Taylor expanded in y around 0
/-lowering-/.f6451.8
Simplified51.8%
Taylor expanded in y around inf
/-lowering-/.f644.3
Simplified4.3%
(FPCore (x y) :precision binary64 (/ (/ (/ x (+ (+ y 1.0) x)) (+ y x)) (/ 1.0 (/ y (+ y x)))))
double code(double x, double y) {
return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x / ((y + 1.0d0) + x)) / (y + x)) / (1.0d0 / (y / (y + x)))
end function
public static double code(double x, double y) {
return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)));
}
def code(x, y): return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)))
function code(x, y) return Float64(Float64(Float64(x / Float64(Float64(y + 1.0) + x)) / Float64(y + x)) / Float64(1.0 / Float64(y / Float64(y + x)))) end
function tmp = code(x, y) tmp = ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x))); end
code[x_, y_] := N[(N[(N[(x / N[(N[(y + 1.0), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(1.0 / N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\frac{x}{\left(y + 1\right) + x}}{y + x}}{\frac{1}{\frac{y}{y + x}}}
\end{array}
herbie shell --seed 2024199
(FPCore (x y)
:name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, A"
:precision binary64
:alt
(! :herbie-platform default (/ (/ (/ x (+ (+ y 1) x)) (+ y x)) (/ 1 (/ y (+ y x)))))
(/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))