
(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 26 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 71.8%
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%
Final simplification99.8%
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ y (+ x 1.0))))
(if (<= x -7e+170)
(/ (/ y t_0) (fma y 2.0 x))
(if (<= x -1.65e-15)
(/ y (* (+ y x) t_0))
(/ x (* (+ y x) (* (/ (+ y x) y) (+ y 1.0))))))))
double code(double x, double y) {
double t_0 = y + (x + 1.0);
double tmp;
if (x <= -7e+170) {
tmp = (y / t_0) / fma(y, 2.0, x);
} else if (x <= -1.65e-15) {
tmp = y / ((y + x) * t_0);
} else {
tmp = x / ((y + x) * (((y + x) / y) * (y + 1.0)));
}
return tmp;
}
function code(x, y) t_0 = Float64(y + Float64(x + 1.0)) tmp = 0.0 if (x <= -7e+170) tmp = Float64(Float64(y / t_0) / fma(y, 2.0, x)); elseif (x <= -1.65e-15) tmp = Float64(y / Float64(Float64(y + x) * t_0)); else tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(Float64(y + x) / y) * Float64(y + 1.0)))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7e+170], N[(N[(y / t$95$0), $MachinePrecision] / N[(y * 2.0 + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.65e-15], N[(y / N[(N[(y + x), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision] * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y + \left(x + 1\right)\\
\mathbf{if}\;x \leq -7 \cdot 10^{+170}:\\
\;\;\;\;\frac{\frac{y}{t\_0}}{\mathsf{fma}\left(y, 2, x\right)}\\
\mathbf{elif}\;x \leq -1.65 \cdot 10^{-15}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \left(\frac{y + x}{y} \cdot \left(y + 1\right)\right)}\\
\end{array}
\end{array}
if x < -7.00000000000000011e170Initial program 50.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6487.2
Simplified87.2%
if -7.00000000000000011e170 < x < -1.65e-15Initial program 71.8%
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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.1
Applied egg-rr98.1%
Taylor expanded in y around 0
Simplified66.7%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lft-identityN/A
+-lowering-+.f6489.0
Applied egg-rr89.0%
if -1.65e-15 < x Initial program 75.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%
associate-/l*N/A
*-commutativeN/A
associate-/l/N/A
times-fracN/A
associate-*r/N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
clear-numN/A
associate-/l/N/A
clear-numN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-/r/N/A
Applied egg-rr92.6%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f6488.6
Simplified88.6%
Final simplification88.5%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ y (+ y x))))
(if (<= x -1.2e+26)
(/ t_0 (fma y (+ 2.0 (/ y x)) x))
(/ (* x t_0) (* (+ y x) (+ (+ y x) 1.0))))))
double code(double x, double y) {
double t_0 = y / (y + x);
double tmp;
if (x <= -1.2e+26) {
tmp = t_0 / fma(y, (2.0 + (y / x)), x);
} else {
tmp = (x * t_0) / ((y + x) * ((y + x) + 1.0));
}
return tmp;
}
function code(x, y) t_0 = Float64(y / Float64(y + x)) tmp = 0.0 if (x <= -1.2e+26) tmp = Float64(t_0 / fma(y, Float64(2.0 + Float64(y / x)), x)); else tmp = Float64(Float64(x * t_0) / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.2e+26], N[(t$95$0 / N[(y * N[(2.0 + N[(y / x), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], N[(N[(x * t$95$0), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{y}{y + x}\\
\mathbf{if}\;x \leq -1.2 \cdot 10^{+26}:\\
\;\;\;\;\frac{t\_0}{\mathsf{fma}\left(y, 2 + \frac{y}{x}, x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot t\_0}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\end{array}
\end{array}
if x < -1.20000000000000002e26Initial program 57.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-+.f6499.8
Applied egg-rr99.8%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.6
Applied egg-rr98.6%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6498.6
Simplified98.6%
Taylor expanded in x around inf
Simplified98.6%
if -1.20000000000000002e26 < x Initial program 76.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-+.f6495.9
Applied egg-rr95.9%
Final simplification96.6%
(FPCore (x y)
:precision binary64
(if (<= y 2.7e-171)
(/ (/ y (+ y (+ x 1.0))) (fma y 2.0 x))
(if (<= y 5.6e+102)
(* x (/ y (* (+ (+ y x) 1.0) (* (+ y x) (+ y x)))))
(/ (/ x y) (+ y x)))))
double code(double x, double y) {
double tmp;
if (y <= 2.7e-171) {
tmp = (y / (y + (x + 1.0))) / fma(y, 2.0, x);
} else if (y <= 5.6e+102) {
tmp = x * (y / (((y + x) + 1.0) * ((y + x) * (y + x))));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 2.7e-171) tmp = Float64(Float64(y / Float64(y + Float64(x + 1.0))) / fma(y, 2.0, x)); elseif (y <= 5.6e+102) tmp = Float64(x * Float64(y / Float64(Float64(Float64(y + x) + 1.0) * Float64(Float64(y + x) * Float64(y + x))))); else tmp = Float64(Float64(x / y) / Float64(y + x)); end return tmp end
code[x_, y_] := If[LessEqual[y, 2.7e-171], N[(N[(y / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0 + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.6e+102], 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 / y), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.7 \cdot 10^{-171}:\\
\;\;\;\;\frac{\frac{y}{y + \left(x + 1\right)}}{\mathsf{fma}\left(y, 2, x\right)}\\
\mathbf{elif}\;y \leq 5.6 \cdot 10^{+102}:\\
\;\;\;\;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}}{y + x}\\
\end{array}
\end{array}
if y < 2.70000000000000014e-171Initial program 72.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.0
Applied egg-rr99.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6463.1
Simplified63.1%
if 2.70000000000000014e-171 < y < 5.60000000000000037e102Initial program 82.3%
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.4
Applied egg-rr89.4%
if 5.60000000000000037e102 < 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-+.f6499.9
Applied egg-rr99.9%
Taylor expanded in y around inf
/-lowering-/.f6479.8
Simplified79.8%
Final simplification72.7%
(FPCore (x y)
:precision binary64
(if (<= y 2.6e-171)
(/ (/ y (+ y (+ x 1.0))) (fma y 2.0 x))
(if (<= y 1.26e+47)
(* y (/ x (* (+ (+ y x) 1.0) (* (+ y x) (+ y x)))))
(/ (/ x y) (+ y x)))))
double code(double x, double y) {
double tmp;
if (y <= 2.6e-171) {
tmp = (y / (y + (x + 1.0))) / fma(y, 2.0, x);
} else if (y <= 1.26e+47) {
tmp = y * (x / (((y + x) + 1.0) * ((y + x) * (y + x))));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 2.6e-171) tmp = Float64(Float64(y / Float64(y + Float64(x + 1.0))) / fma(y, 2.0, x)); elseif (y <= 1.26e+47) tmp = Float64(y * Float64(x / Float64(Float64(Float64(y + x) + 1.0) * Float64(Float64(y + x) * Float64(y + x))))); else tmp = Float64(Float64(x / y) / Float64(y + x)); end return tmp end
code[x_, y_] := If[LessEqual[y, 2.6e-171], N[(N[(y / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0 + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.26e+47], N[(y * N[(x / 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 / y), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.6 \cdot 10^{-171}:\\
\;\;\;\;\frac{\frac{y}{y + \left(x + 1\right)}}{\mathsf{fma}\left(y, 2, x\right)}\\
\mathbf{elif}\;y \leq 1.26 \cdot 10^{+47}:\\
\;\;\;\;y \cdot \frac{x}{\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}}{y + x}\\
\end{array}
\end{array}
if y < 2.60000000000000005e-171Initial program 72.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.0
Applied egg-rr99.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6463.1
Simplified63.1%
if 2.60000000000000005e-171 < y < 1.26e47Initial program 80.5%
*-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-+.f6489.2
Applied egg-rr89.2%
if 1.26e47 < y Initial program 63.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.8
Applied egg-rr99.8%
Taylor expanded in y around inf
/-lowering-/.f6480.3
Simplified80.3%
Final simplification72.3%
(FPCore (x y) :precision binary64 (if (<= x -1.15e+162) (/ (/ y x) (* (+ y x) (/ (+ y x) x))) (/ (* x (/ y (+ y x))) (* (+ y x) (+ (+ y x) 1.0)))))
double code(double x, double y) {
double tmp;
if (x <= -1.15e+162) {
tmp = (y / x) / ((y + x) * ((y + x) / x));
} else {
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 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 <= (-1.15d+162)) then
tmp = (y / x) / ((y + x) * ((y + x) / x))
else
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0d0))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -1.15e+162) {
tmp = (y / x) / ((y + x) * ((y + x) / x));
} else {
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0));
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.15e+162: tmp = (y / x) / ((y + x) * ((y + x) / x)) else: tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0)) return tmp
function code(x, y) tmp = 0.0 if (x <= -1.15e+162) tmp = Float64(Float64(y / x) / Float64(Float64(y + x) * Float64(Float64(y + x) / x))); else tmp = Float64(Float64(x * Float64(y / Float64(y + x))) / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -1.15e+162) tmp = (y / x) / ((y + x) * ((y + x) / x)); else tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.15e+162], N[(N[(y / x), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.15 \cdot 10^{+162}:\\
\;\;\;\;\frac{\frac{y}{x}}{\left(y + x\right) \cdot \frac{y + x}{x}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \frac{y}{y + x}}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\end{array}
\end{array}
if x < -1.14999999999999997e162Initial program 47.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.8
Applied egg-rr99.8%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
Taylor expanded in x around inf
/-lowering-/.f6488.6
Simplified88.6%
if -1.14999999999999997e162 < x Initial program 75.3%
*-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-+.f6496.1
Applied egg-rr96.1%
Final simplification95.2%
(FPCore (x y) :precision binary64 (if (<= x -4.9e+172) (/ (/ y (+ y (+ x 1.0))) (fma y 2.0 x)) (/ (* x (/ y (+ y x))) (* (+ y x) (+ (+ y x) 1.0)))))
double code(double x, double y) {
double tmp;
if (x <= -4.9e+172) {
tmp = (y / (y + (x + 1.0))) / fma(y, 2.0, x);
} else {
tmp = (x * (y / (y + x))) / ((y + x) * ((y + x) + 1.0));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -4.9e+172) tmp = Float64(Float64(y / Float64(y + Float64(x + 1.0))) / fma(y, 2.0, x)); else tmp = Float64(Float64(x * Float64(y / Float64(y + x))) / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0))); end return tmp end
code[x_, y_] := If[LessEqual[x, -4.9e+172], N[(N[(y / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0 + x), $MachinePrecision]), $MachinePrecision], 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]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -4.9 \cdot 10^{+172}:\\
\;\;\;\;\frac{\frac{y}{y + \left(x + 1\right)}}{\mathsf{fma}\left(y, 2, x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \frac{y}{y + x}}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\end{array}
\end{array}
if x < -4.9000000000000001e172Initial program 50.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6487.2
Simplified87.2%
if -4.9000000000000001e172 < x Initial program 74.4%
*-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-+.f6495.3
Applied egg-rr95.3%
Final simplification94.5%
(FPCore (x y) :precision binary64 (if (<= x -3.3e+172) (/ (/ y (+ y (+ x 1.0))) (fma y 2.0 x)) (* (/ y (+ y x)) (/ x (* (+ y x) (+ (+ y x) 1.0))))))
double code(double x, double y) {
double tmp;
if (x <= -3.3e+172) {
tmp = (y / (y + (x + 1.0))) / fma(y, 2.0, x);
} else {
tmp = (y / (y + x)) * (x / ((y + x) * ((y + x) + 1.0)));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -3.3e+172) tmp = Float64(Float64(y / Float64(y + Float64(x + 1.0))) / fma(y, 2.0, x)); else tmp = Float64(Float64(y / Float64(y + x)) * Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) + 1.0)))); end return tmp end
code[x_, y_] := If[LessEqual[x, -3.3e+172], N[(N[(y / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0 + x), $MachinePrecision]), $MachinePrecision], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.3 \cdot 10^{+172}:\\
\;\;\;\;\frac{\frac{y}{y + \left(x + 1\right)}}{\mathsf{fma}\left(y, 2, x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{y + x} \cdot \frac{x}{\left(y + x\right) \cdot \left(\left(y + x\right) + 1\right)}\\
\end{array}
\end{array}
if x < -3.29999999999999983e172Initial program 50.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6487.2
Simplified87.2%
if -3.29999999999999983e172 < x Initial program 74.4%
*-commutativeN/A
associate-*l*N/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6495.3
Applied egg-rr95.3%
Final simplification94.4%
(FPCore (x y) :precision binary64 (* (/ x (+ y x)) (/ (/ y (+ (+ y x) 1.0)) (+ y x))))
double code(double x, double y) {
return (x / (y + x)) * ((y / ((y + x) + 1.0)) / (y + x));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (x / (y + x)) * ((y / ((y + x) + 1.0d0)) / (y + x))
end function
public static double code(double x, double y) {
return (x / (y + x)) * ((y / ((y + x) + 1.0)) / (y + x));
}
def code(x, y): return (x / (y + x)) * ((y / ((y + x) + 1.0)) / (y + x))
function code(x, y) return Float64(Float64(x / Float64(y + x)) * Float64(Float64(y / Float64(Float64(y + x) + 1.0)) / Float64(y + x))) end
function tmp = code(x, y) tmp = (x / (y + x)) * ((y / ((y + x) + 1.0)) / (y + x)); end
code[x_, y_] := N[(N[(x / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(N[(y / N[(N[(y + x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y + x} \cdot \frac{\frac{y}{\left(y + x\right) + 1}}{y + x}
\end{array}
Initial program 71.8%
times-fracN/A
associate-*l/N/A
times-fracN/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%
Final simplification99.8%
(FPCore (x y) :precision binary64 (/ (/ y (+ y (+ x 1.0))) (fma y (+ 2.0 (/ y x)) x)))
double code(double x, double y) {
return (y / (y + (x + 1.0))) / fma(y, (2.0 + (y / x)), x);
}
function code(x, y) return Float64(Float64(y / Float64(y + Float64(x + 1.0))) / fma(y, Float64(2.0 + Float64(y / x)), x)) end
code[x_, y_] := N[(N[(y / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * N[(2.0 + N[(y / x), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{y}{y + \left(x + 1\right)}}{\mathsf{fma}\left(y, 2 + \frac{y}{x}, x\right)}
\end{array}
Initial program 71.8%
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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.1
Applied egg-rr99.1%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6499.1
Simplified99.1%
(FPCore (x y)
:precision binary64
(if (<= y 2.7e-171)
(/ (/ y (+ y (+ x 1.0))) (fma y 2.0 x))
(if (<= y 8.6e+24)
(* x (/ y (* (+ x 1.0) (* (+ y x) (+ y x)))))
(/ (/ x y) (+ y x)))))
double code(double x, double y) {
double tmp;
if (y <= 2.7e-171) {
tmp = (y / (y + (x + 1.0))) / fma(y, 2.0, x);
} else if (y <= 8.6e+24) {
tmp = x * (y / ((x + 1.0) * ((y + x) * (y + x))));
} else {
tmp = (x / y) / (y + x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 2.7e-171) tmp = Float64(Float64(y / Float64(y + Float64(x + 1.0))) / fma(y, 2.0, x)); elseif (y <= 8.6e+24) tmp = Float64(x * Float64(y / Float64(Float64(x + 1.0) * Float64(Float64(y + x) * Float64(y + x))))); else tmp = Float64(Float64(x / y) / Float64(y + x)); end return tmp end
code[x_, y_] := If[LessEqual[y, 2.7e-171], N[(N[(y / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y * 2.0 + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.6e+24], N[(x * N[(y / N[(N[(x + 1.0), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.7 \cdot 10^{-171}:\\
\;\;\;\;\frac{\frac{y}{y + \left(x + 1\right)}}{\mathsf{fma}\left(y, 2, x\right)}\\
\mathbf{elif}\;y \leq 8.6 \cdot 10^{+24}:\\
\;\;\;\;x \cdot \frac{y}{\left(x + 1\right) \cdot \left(\left(y + x\right) \cdot \left(y + x\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y + x}\\
\end{array}
\end{array}
if y < 2.70000000000000014e-171Initial program 72.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.0
Applied egg-rr99.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6463.1
Simplified63.1%
if 2.70000000000000014e-171 < y < 8.59999999999999975e24Initial program 84.1%
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.5
Applied egg-rr89.5%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f6486.5
Simplified86.5%
if 8.59999999999999975e24 < y Initial program 62.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%
Taylor expanded in y around inf
/-lowering-/.f6476.8
Simplified76.8%
Final simplification70.7%
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ y (+ x 1.0))))
(if (<= x -1.35e+171)
(/ (/ y t_0) (fma y 2.0 x))
(if (<= x -1.5e-80)
(/ y (* (+ y x) t_0))
(/ (* x (/ 1.0 y)) (+ y 1.0))))))
double code(double x, double y) {
double t_0 = y + (x + 1.0);
double tmp;
if (x <= -1.35e+171) {
tmp = (y / t_0) / fma(y, 2.0, x);
} else if (x <= -1.5e-80) {
tmp = y / ((y + x) * t_0);
} else {
tmp = (x * (1.0 / y)) / (y + 1.0);
}
return tmp;
}
function code(x, y) t_0 = Float64(y + Float64(x + 1.0)) tmp = 0.0 if (x <= -1.35e+171) tmp = Float64(Float64(y / t_0) / fma(y, 2.0, x)); elseif (x <= -1.5e-80) tmp = Float64(y / Float64(Float64(y + x) * t_0)); else tmp = Float64(Float64(x * Float64(1.0 / y)) / Float64(y + 1.0)); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.35e+171], N[(N[(y / t$95$0), $MachinePrecision] / N[(y * 2.0 + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.5e-80], N[(y / N[(N[(y + x), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(1.0 / y), $MachinePrecision]), $MachinePrecision] / N[(y + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y + \left(x + 1\right)\\
\mathbf{if}\;x \leq -1.35 \cdot 10^{+171}:\\
\;\;\;\;\frac{\frac{y}{t\_0}}{\mathsf{fma}\left(y, 2, x\right)}\\
\mathbf{elif}\;x \leq -1.5 \cdot 10^{-80}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \frac{1}{y}}{y + 1}\\
\end{array}
\end{array}
if x < -1.3499999999999999e171Initial program 50.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.8
Applied egg-rr99.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6487.2
Simplified87.2%
if -1.3499999999999999e171 < x < -1.50000000000000004e-80Initial program 77.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.5
Applied egg-rr98.5%
Taylor expanded in y around 0
Simplified56.9%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lft-identityN/A
+-lowering-+.f6484.0
Applied egg-rr84.0%
if -1.50000000000000004e-80 < x Initial program 73.3%
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-+.f6484.4
Applied egg-rr84.4%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6457.4
Simplified57.4%
associate-/r*N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6458.0
Applied egg-rr58.0%
Final simplification67.5%
(FPCore (x y)
:precision binary64
(if (<= x -6e+170)
(/ (/ y x) (+ y x))
(if (<= x -4.7e-79)
(/ y (* (+ y x) (+ y (+ x 1.0))))
(/ (* x (/ 1.0 y)) (+ y 1.0)))))
double code(double x, double y) {
double tmp;
if (x <= -6e+170) {
tmp = (y / x) / (y + x);
} else if (x <= -4.7e-79) {
tmp = y / ((y + x) * (y + (x + 1.0)));
} else {
tmp = (x * (1.0 / y)) / (y + 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 <= (-6d+170)) then
tmp = (y / x) / (y + x)
else if (x <= (-4.7d-79)) then
tmp = y / ((y + x) * (y + (x + 1.0d0)))
else
tmp = (x * (1.0d0 / y)) / (y + 1.0d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -6e+170) {
tmp = (y / x) / (y + x);
} else if (x <= -4.7e-79) {
tmp = y / ((y + x) * (y + (x + 1.0)));
} else {
tmp = (x * (1.0 / y)) / (y + 1.0);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -6e+170: tmp = (y / x) / (y + x) elif x <= -4.7e-79: tmp = y / ((y + x) * (y + (x + 1.0))) else: tmp = (x * (1.0 / y)) / (y + 1.0) return tmp
function code(x, y) tmp = 0.0 if (x <= -6e+170) tmp = Float64(Float64(y / x) / Float64(y + x)); elseif (x <= -4.7e-79) tmp = Float64(y / Float64(Float64(y + x) * Float64(y + Float64(x + 1.0)))); else tmp = Float64(Float64(x * Float64(1.0 / y)) / Float64(y + 1.0)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -6e+170) tmp = (y / x) / (y + x); elseif (x <= -4.7e-79) tmp = y / ((y + x) * (y + (x + 1.0))); else tmp = (x * (1.0 / y)) / (y + 1.0); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -6e+170], N[(N[(y / x), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4.7e-79], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(1.0 / y), $MachinePrecision]), $MachinePrecision] / N[(y + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6 \cdot 10^{+170}:\\
\;\;\;\;\frac{\frac{y}{x}}{y + x}\\
\mathbf{elif}\;x \leq -4.7 \cdot 10^{-79}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + \left(x + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \frac{1}{y}}{y + 1}\\
\end{array}
\end{array}
if x < -5.99999999999999994e170Initial program 50.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
/-lowering-/.f6487.0
Simplified87.0%
if -5.99999999999999994e170 < x < -4.7000000000000002e-79Initial program 77.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.5
Applied egg-rr98.5%
Taylor expanded in y around 0
Simplified56.9%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lft-identityN/A
+-lowering-+.f6484.0
Applied egg-rr84.0%
if -4.7000000000000002e-79 < x Initial program 73.3%
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-+.f6484.4
Applied egg-rr84.4%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6457.4
Simplified57.4%
associate-/r*N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6458.0
Applied egg-rr58.0%
Final simplification67.4%
(FPCore (x y)
:precision binary64
(if (<= x -1.18e+173)
(/ (/ y x) (+ y x))
(if (<= x -6.2e-79)
(/ y (* (+ y x) (+ y (+ x 1.0))))
(/ (/ x (+ y 1.0)) (+ y x)))))
double code(double x, double y) {
double tmp;
if (x <= -1.18e+173) {
tmp = (y / x) / (y + x);
} else if (x <= -6.2e-79) {
tmp = y / ((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 (x <= (-1.18d+173)) then
tmp = (y / x) / (y + x)
else if (x <= (-6.2d-79)) then
tmp = y / ((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 (x <= -1.18e+173) {
tmp = (y / x) / (y + x);
} else if (x <= -6.2e-79) {
tmp = y / ((y + x) * (y + (x + 1.0)));
} else {
tmp = (x / (y + 1.0)) / (y + x);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.18e+173: tmp = (y / x) / (y + x) elif x <= -6.2e-79: tmp = y / ((y + x) * (y + (x + 1.0))) else: tmp = (x / (y + 1.0)) / (y + x) return tmp
function code(x, y) tmp = 0.0 if (x <= -1.18e+173) tmp = Float64(Float64(y / x) / Float64(y + x)); elseif (x <= -6.2e-79) tmp = Float64(y / Float64(Float64(y + x) * Float64(y + Float64(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 (x <= -1.18e+173) tmp = (y / x) / (y + x); elseif (x <= -6.2e-79) tmp = y / ((y + x) * (y + (x + 1.0))); else tmp = (x / (y + 1.0)) / (y + x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.18e+173], N[(N[(y / x), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6.2e-79], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + N[(x + 1.0), $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}\;x \leq -1.18 \cdot 10^{+173}:\\
\;\;\;\;\frac{\frac{y}{x}}{y + x}\\
\mathbf{elif}\;x \leq -6.2 \cdot 10^{-79}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + \left(x + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\
\end{array}
\end{array}
if x < -1.18e173Initial program 50.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
/-lowering-/.f6487.0
Simplified87.0%
if -1.18e173 < x < -6.1999999999999999e-79Initial program 77.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.5
Applied egg-rr98.5%
Taylor expanded in y around 0
Simplified56.9%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lft-identityN/A
+-lowering-+.f6484.0
Applied egg-rr84.0%
if -6.1999999999999999e-79 < x Initial program 73.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 0
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f6458.4
Simplified58.4%
Final simplification67.7%
(FPCore (x y) :precision binary64 (if (<= x -2.1e+170) (/ (/ y x) (+ y x)) (if (<= x -2.2e-79) (/ y (* (+ y x) (+ y (+ x 1.0)))) (/ x (fma y y y)))))
double code(double x, double y) {
double tmp;
if (x <= -2.1e+170) {
tmp = (y / x) / (y + x);
} else if (x <= -2.2e-79) {
tmp = y / ((y + x) * (y + (x + 1.0)));
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2.1e+170) tmp = Float64(Float64(y / x) / Float64(y + x)); elseif (x <= -2.2e-79) tmp = Float64(y / Float64(Float64(y + x) * Float64(y + Float64(x + 1.0)))); else tmp = Float64(x / fma(y, y, y)); end return tmp end
code[x_, y_] := If[LessEqual[x, -2.1e+170], N[(N[(y / x), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.2e-79], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.1 \cdot 10^{+170}:\\
\;\;\;\;\frac{\frac{y}{x}}{y + x}\\
\mathbf{elif}\;x \leq -2.2 \cdot 10^{-79}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + \left(x + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -2.09999999999999998e170Initial program 50.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
/-lowering-/.f6487.0
Simplified87.0%
if -2.09999999999999998e170 < x < -2.1999999999999999e-79Initial program 77.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.5
Applied egg-rr98.5%
Taylor expanded in y around 0
Simplified56.9%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lft-identityN/A
+-lowering-+.f6484.0
Applied egg-rr84.0%
if -2.1999999999999999e-79 < x Initial program 73.3%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6457.5
Simplified57.5%
Final simplification67.1%
(FPCore (x y) :precision binary64 (if (<= x -3.5e+172) (/ (/ y x) x) (if (<= x -7e-81) (/ y (* (+ y x) (+ y (+ x 1.0)))) (/ x (fma y y y)))))
double code(double x, double y) {
double tmp;
if (x <= -3.5e+172) {
tmp = (y / x) / x;
} else if (x <= -7e-81) {
tmp = y / ((y + x) * (y + (x + 1.0)));
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -3.5e+172) tmp = Float64(Float64(y / x) / x); elseif (x <= -7e-81) tmp = Float64(y / Float64(Float64(y + x) * Float64(y + Float64(x + 1.0)))); else tmp = Float64(x / fma(y, y, y)); end return tmp end
code[x_, y_] := If[LessEqual[x, -3.5e+172], N[(N[(y / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, -7e-81], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.5 \cdot 10^{+172}:\\
\;\;\;\;\frac{\frac{y}{x}}{x}\\
\mathbf{elif}\;x \leq -7 \cdot 10^{-81}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + \left(x + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -3.49999999999999977e172Initial program 50.2%
Taylor expanded in x around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6472.9
Simplified72.9%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f6486.8
Applied egg-rr86.8%
if -3.49999999999999977e172 < x < -6.99999999999999973e-81Initial program 77.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%
*-commutativeN/A
associate-*r/N/A
clear-numN/A
frac-timesN/A
*-lft-identityN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.5
Applied egg-rr98.5%
Taylor expanded in y around 0
Simplified56.9%
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lft-identityN/A
+-lowering-+.f6484.0
Applied egg-rr84.0%
if -6.99999999999999973e-81 < x Initial program 73.3%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6457.5
Simplified57.5%
Final simplification67.1%
(FPCore (x y) :precision binary64 (if (<= y -2.9e-212) (/ y (* x x)) (if (<= y 2.25e-161) (/ y x) (if (<= y 1.0) (/ x y) (/ x (* y y))))))
double code(double x, double y) {
double tmp;
if (y <= -2.9e-212) {
tmp = y / (x * x);
} else if (y <= 2.25e-161) {
tmp = y / x;
} else if (y <= 1.0) {
tmp = x / y;
} 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 <= (-2.9d-212)) then
tmp = y / (x * x)
else if (y <= 2.25d-161) then
tmp = y / x
else if (y <= 1.0d0) then
tmp = x / y
else
tmp = x / (y * y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -2.9e-212) {
tmp = y / (x * x);
} else if (y <= 2.25e-161) {
tmp = y / x;
} else if (y <= 1.0) {
tmp = x / y;
} else {
tmp = x / (y * y);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -2.9e-212: tmp = y / (x * x) elif y <= 2.25e-161: tmp = y / x elif y <= 1.0: tmp = x / y else: tmp = x / (y * y) return tmp
function code(x, y) tmp = 0.0 if (y <= -2.9e-212) tmp = Float64(y / Float64(x * x)); elseif (y <= 2.25e-161) tmp = Float64(y / x); elseif (y <= 1.0) tmp = Float64(x / y); else tmp = Float64(x / Float64(y * y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -2.9e-212) tmp = y / (x * x); elseif (y <= 2.25e-161) tmp = y / x; elseif (y <= 1.0) tmp = x / y; else tmp = x / (y * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -2.9e-212], N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.25e-161], N[(y / x), $MachinePrecision], If[LessEqual[y, 1.0], N[(x / y), $MachinePrecision], N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.9 \cdot 10^{-212}:\\
\;\;\;\;\frac{y}{x \cdot x}\\
\mathbf{elif}\;y \leq 2.25 \cdot 10^{-161}:\\
\;\;\;\;\frac{y}{x}\\
\mathbf{elif}\;y \leq 1:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot y}\\
\end{array}
\end{array}
if y < -2.8999999999999999e-212Initial program 73.0%
Taylor expanded in x around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6435.7
Simplified35.7%
if -2.8999999999999999e-212 < y < 2.2499999999999998e-161Initial program 72.1%
Taylor expanded in y around 0
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6472.1
Simplified72.1%
Taylor expanded in x around 0
/-lowering-/.f6488.3
Simplified88.3%
if 2.2499999999999998e-161 < y < 1Initial program 86.9%
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-+.f6493.1
Applied egg-rr93.1%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6446.5
Simplified46.5%
Taylor expanded in y around 0
/-lowering-/.f6445.7
Simplified45.7%
if 1 < y Initial program 62.1%
Taylor expanded in y around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6474.4
Simplified74.4%
(FPCore (x y) :precision binary64 (if (<= y 2.65e-161) (/ y (fma x x x)) (if (<= y 2.9e+175) (/ x (* (+ y x) (+ y 1.0))) (/ (/ x y) y))))
double code(double x, double y) {
double tmp;
if (y <= 2.65e-161) {
tmp = y / fma(x, x, x);
} else if (y <= 2.9e+175) {
tmp = x / ((y + x) * (y + 1.0));
} else {
tmp = (x / y) / y;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 2.65e-161) tmp = Float64(y / fma(x, x, x)); elseif (y <= 2.9e+175) tmp = Float64(x / Float64(Float64(y + x) * Float64(y + 1.0))); else tmp = Float64(Float64(x / y) / y); end return tmp end
code[x_, y_] := If[LessEqual[y, 2.65e-161], N[(y / N[(x * x + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.9e+175], N[(x / N[(N[(y + x), $MachinePrecision] * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.65 \cdot 10^{-161}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(x, x, x\right)}\\
\mathbf{elif}\;y \leq 2.9 \cdot 10^{+175}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \left(y + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y}\\
\end{array}
\end{array}
if y < 2.65000000000000014e-161Initial program 72.7%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6458.2
Simplified58.2%
if 2.65000000000000014e-161 < y < 2.9e175Initial program 76.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%
associate-/l*N/A
*-commutativeN/A
associate-/l/N/A
times-fracN/A
associate-*r/N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
clear-numN/A
associate-/l/N/A
clear-numN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-/r/N/A
Applied egg-rr89.8%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f6459.8
Simplified59.8%
if 2.9e175 < y Initial program 59.5%
Taylor expanded in y around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6486.1
Simplified86.1%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f6484.4
Applied egg-rr84.4%
(FPCore (x y) :precision binary64 (if (<= x -1.55e+173) (/ (/ y x) x) (if (<= x -2.6e-78) (/ y (fma x x x)) (/ x (fma y y y)))))
double code(double x, double y) {
double tmp;
if (x <= -1.55e+173) {
tmp = (y / x) / x;
} else if (x <= -2.6e-78) {
tmp = y / fma(x, x, x);
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -1.55e+173) tmp = Float64(Float64(y / x) / x); elseif (x <= -2.6e-78) 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, -1.55e+173], N[(N[(y / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, -2.6e-78], 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 -1.55 \cdot 10^{+173}:\\
\;\;\;\;\frac{\frac{y}{x}}{x}\\
\mathbf{elif}\;x \leq -2.6 \cdot 10^{-78}:\\
\;\;\;\;\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 < -1.55e173Initial program 50.2%
Taylor expanded in x around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6472.9
Simplified72.9%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f6486.8
Applied egg-rr86.8%
if -1.55e173 < x < -2.6000000000000001e-78Initial program 77.5%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6455.7
Simplified55.7%
if -2.6000000000000001e-78 < x Initial program 73.3%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6457.5
Simplified57.5%
(FPCore (x y) :precision binary64 (if (<= y 2.7e-161) (/ y x) (if (<= y 1.0) (/ x y) (/ x (* y y)))))
double code(double x, double y) {
double tmp;
if (y <= 2.7e-161) {
tmp = y / x;
} else if (y <= 1.0) {
tmp = x / y;
} 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 <= 2.7d-161) then
tmp = y / x
else if (y <= 1.0d0) then
tmp = x / y
else
tmp = x / (y * y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 2.7e-161) {
tmp = y / x;
} else if (y <= 1.0) {
tmp = x / y;
} else {
tmp = x / (y * y);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 2.7e-161: tmp = y / x elif y <= 1.0: tmp = x / y else: tmp = x / (y * y) return tmp
function code(x, y) tmp = 0.0 if (y <= 2.7e-161) tmp = Float64(y / x); elseif (y <= 1.0) tmp = Float64(x / y); else tmp = Float64(x / Float64(y * y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 2.7e-161) tmp = y / x; elseif (y <= 1.0) tmp = x / y; else tmp = x / (y * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 2.7e-161], N[(y / x), $MachinePrecision], If[LessEqual[y, 1.0], N[(x / y), $MachinePrecision], N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.7 \cdot 10^{-161}:\\
\;\;\;\;\frac{y}{x}\\
\mathbf{elif}\;y \leq 1:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot y}\\
\end{array}
\end{array}
if y < 2.6999999999999999e-161Initial program 72.7%
Taylor expanded in y around 0
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6443.5
Simplified43.5%
Taylor expanded in x around 0
/-lowering-/.f6435.2
Simplified35.2%
if 2.6999999999999999e-161 < y < 1Initial program 86.9%
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-+.f6493.1
Applied egg-rr93.1%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6446.5
Simplified46.5%
Taylor expanded in y around 0
/-lowering-/.f6445.7
Simplified45.7%
if 1 < y Initial program 62.1%
Taylor expanded in y around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6474.4
Simplified74.4%
(FPCore (x y) :precision binary64 (if (<= y 2.7e-161) (/ y (fma x x x)) (/ x (* (+ y x) (+ y 1.0)))))
double code(double x, double y) {
double tmp;
if (y <= 2.7e-161) {
tmp = y / fma(x, x, x);
} else {
tmp = x / ((y + x) * (y + 1.0));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (y <= 2.7e-161) tmp = Float64(y / fma(x, x, x)); else tmp = Float64(x / Float64(Float64(y + x) * Float64(y + 1.0))); end return tmp end
code[x_, y_] := If[LessEqual[y, 2.7e-161], N[(y / N[(x * x + x), $MachinePrecision]), $MachinePrecision], N[(x / N[(N[(y + x), $MachinePrecision] * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 2.7 \cdot 10^{-161}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(x, x, x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \left(y + 1\right)}\\
\end{array}
\end{array}
if y < 2.6999999999999999e-161Initial program 72.7%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6458.2
Simplified58.2%
if 2.6999999999999999e-161 < y Initial program 70.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
*-commutativeN/A
associate-/l/N/A
times-fracN/A
associate-*r/N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
clear-numN/A
associate-/l/N/A
clear-numN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-/r/N/A
Applied egg-rr88.5%
Taylor expanded in x around 0
+-commutativeN/A
+-lowering-+.f6468.6
Simplified68.6%
(FPCore (x y) :precision binary64 (if (<= x -2.6e-78) (/ y (fma x x x)) (/ x (fma y y y))))
double code(double x, double y) {
double tmp;
if (x <= -2.6e-78) {
tmp = y / fma(x, x, x);
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2.6e-78) 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, -2.6e-78], 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 -2.6 \cdot 10^{-78}:\\
\;\;\;\;\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 < -2.6000000000000001e-78Initial program 69.0%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6461.0
Simplified61.0%
if -2.6000000000000001e-78 < x Initial program 73.3%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6457.5
Simplified57.5%
(FPCore (x y) :precision binary64 (if (<= x -2.9) (/ y (* x x)) (/ x (fma y y y))))
double code(double x, double y) {
double tmp;
if (x <= -2.9) {
tmp = y / (x * x);
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2.9) tmp = Float64(y / Float64(x * x)); else tmp = Float64(x / fma(y, y, y)); end return tmp end
code[x_, y_] := If[LessEqual[x, -2.9], 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 -2.9:\\
\;\;\;\;\frac{y}{x \cdot x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -2.89999999999999991Initial program 62.6%
Taylor expanded in x around inf
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6464.3
Simplified64.3%
if -2.89999999999999991 < x Initial program 75.4%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6458.5
Simplified58.5%
(FPCore (x y) :precision binary64 (if (<= x -2.85e-95) (/ y x) (/ x y)))
double code(double x, double y) {
double tmp;
if (x <= -2.85e-95) {
tmp = y / x;
} else {
tmp = x / y;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-2.85d-95)) then
tmp = y / x
else
tmp = x / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -2.85e-95) {
tmp = y / x;
} else {
tmp = x / y;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -2.85e-95: tmp = y / x else: tmp = x / y return tmp
function code(x, y) tmp = 0.0 if (x <= -2.85e-95) tmp = Float64(y / x); else tmp = Float64(x / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -2.85e-95) tmp = y / x; else tmp = x / y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -2.85e-95], N[(y / x), $MachinePrecision], N[(x / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.85 \cdot 10^{-95}:\\
\;\;\;\;\frac{y}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y}\\
\end{array}
\end{array}
if x < -2.85e-95Initial program 69.3%
Taylor expanded in y around 0
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f6449.5
Simplified49.5%
Taylor expanded in x around 0
/-lowering-/.f6425.0
Simplified25.0%
if -2.85e-95 < x Initial program 73.1%
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-+.f6484.3
Applied egg-rr84.3%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6457.1
Simplified57.1%
Taylor expanded in y around 0
/-lowering-/.f6434.8
Simplified34.8%
(FPCore (x y) :precision binary64 (if (<= x -1.65e-15) (/ 1.0 x) (/ x y)))
double code(double x, double y) {
double tmp;
if (x <= -1.65e-15) {
tmp = 1.0 / x;
} else {
tmp = x / y;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.65d-15)) then
tmp = 1.0d0 / x
else
tmp = x / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -1.65e-15) {
tmp = 1.0 / x;
} else {
tmp = x / y;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.65e-15: tmp = 1.0 / x else: tmp = x / y return tmp
function code(x, y) tmp = 0.0 if (x <= -1.65e-15) tmp = Float64(1.0 / x); else tmp = Float64(x / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -1.65e-15) tmp = 1.0 / x; else tmp = x / y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.65e-15], N[(1.0 / x), $MachinePrecision], N[(x / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.65 \cdot 10^{-15}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y}\\
\end{array}
\end{array}
if x < -1.65e-15Initial program 63.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.8
Applied egg-rr99.8%
Taylor expanded in y around inf
Simplified29.9%
Taylor expanded in x around inf
/-lowering-/.f645.6
Simplified5.6%
if -1.65e-15 < x Initial program 75.1%
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-+.f6485.2
Applied egg-rr85.2%
Taylor expanded in x around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6459.1
Simplified59.1%
Taylor expanded in y around 0
/-lowering-/.f6433.6
Simplified33.6%
(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 71.8%
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
Simplified41.6%
Taylor expanded in x 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 2024195
(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))))