
(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 21 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}
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (* (/ y (+ y x)) (/ (/ x (+ x (+ y 1.0))) (+ y x))))
assert(x < y);
double code(double x, double y) {
return (y / (y + x)) * ((x / (x + (y + 1.0))) / (y + x));
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (y / (y + x)) * ((x / (x + (y + 1.0d0))) / (y + x))
end function
assert x < y;
public static double code(double x, double y) {
return (y / (y + x)) * ((x / (x + (y + 1.0))) / (y + x));
}
[x, y] = sort([x, y]) def code(x, y): return (y / (y + x)) * ((x / (x + (y + 1.0))) / (y + x))
x, y = sort([x, y]) function code(x, y) return Float64(Float64(y / Float64(y + x)) * Float64(Float64(x / Float64(x + Float64(y + 1.0))) / Float64(y + x))) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = (y / (y + x)) * ((x / (x + (y + 1.0))) / (y + x));
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(N[(x / N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{y}{y + x} \cdot \frac{\frac{x}{x + \left(y + 1\right)}}{y + x}
\end{array}
Initial program 71.5%
associate-+r+71.5%
*-commutative71.5%
frac-times87.6%
associate-*l/83.5%
times-frac99.9%
Applied egg-rr99.9%
Final simplification99.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 9.8e-232)
(/ (/ y (+ y x)) (+ x (+ y (+ y 1.0))))
(if (<= y 2.7e-25)
(/ x (* (+ y x) (/ (+ y x) y)))
(if (<= y 4.3e+173)
(* (/ y (* (+ y x) (+ y x))) (/ x (+ y 1.0)))
(/ (/ x (+ y (+ x 1.0))) (+ y (* x 2.0)))))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 9.8e-232) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else if (y <= 2.7e-25) {
tmp = x / ((y + x) * ((y + x) / y));
} else if (y <= 4.3e+173) {
tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0));
} else {
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 9.8d-232) then
tmp = (y / (y + x)) / (x + (y + (y + 1.0d0)))
else if (y <= 2.7d-25) then
tmp = x / ((y + x) * ((y + x) / y))
else if (y <= 4.3d+173) then
tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0d0))
else
tmp = (x / (y + (x + 1.0d0))) / (y + (x * 2.0d0))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 9.8e-232) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else if (y <= 2.7e-25) {
tmp = x / ((y + x) * ((y + x) / y));
} else if (y <= 4.3e+173) {
tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0));
} else {
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 9.8e-232: tmp = (y / (y + x)) / (x + (y + (y + 1.0))) elif y <= 2.7e-25: tmp = x / ((y + x) * ((y + x) / y)) elif y <= 4.3e+173: tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0)) else: tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 9.8e-232) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + Float64(y + Float64(y + 1.0)))); elseif (y <= 2.7e-25) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) / y))); elseif (y <= 4.3e+173) tmp = Float64(Float64(y / Float64(Float64(y + x) * Float64(y + x))) * Float64(x / Float64(y + 1.0))); else tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + Float64(x * 2.0))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 9.8e-232)
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
elseif (y <= 2.7e-25)
tmp = x / ((y + x) * ((y + x) / y));
elseif (y <= 4.3e+173)
tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0));
else
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 9.8e-232], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.7e-25], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.3e+173], N[(N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 9.8 \cdot 10^{-232}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + \left(y + \left(y + 1\right)\right)}\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{-25}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \frac{y + x}{y}}\\
\mathbf{elif}\;y \leq 4.3 \cdot 10^{+173}:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)} \cdot \frac{x}{y + 1}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y + x \cdot 2}\\
\end{array}
\end{array}
if y < 9.8000000000000006e-232Initial program 70.2%
+-commutative70.2%
+-commutative70.2%
+-commutative70.2%
associate-*l/81.5%
*-commutative81.5%
*-commutative81.5%
distribute-rgt1-in54.2%
fma-define81.5%
+-commutative81.5%
+-commutative81.5%
cube-unmult81.5%
+-commutative81.5%
Simplified81.5%
associate-*r/70.3%
fma-undefine50.7%
cube-mult50.7%
distribute-rgt1-in70.2%
associate-+r+70.2%
*-commutative70.2%
frac-times87.1%
*-commutative87.1%
associate-/r*99.8%
clear-num99.8%
frac-times99.1%
*-un-lft-identity99.1%
Applied egg-rr99.1%
Taylor expanded in x around -inf 58.6%
mul-1-neg58.6%
unsub-neg58.6%
neg-mul-158.6%
+-commutative58.6%
unsub-neg58.6%
distribute-lft-in58.6%
metadata-eval58.6%
neg-mul-158.6%
unsub-neg58.6%
Simplified58.6%
if 9.8000000000000006e-232 < y < 2.70000000000000016e-25Initial program 78.6%
associate-+r+78.6%
*-commutative78.6%
frac-times90.0%
associate-*l/80.9%
times-frac100.0%
Applied egg-rr100.0%
clear-num99.9%
frac-times99.8%
*-un-lft-identity99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+l+99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
Taylor expanded in x around 0 91.8%
+-commutative91.8%
Simplified91.8%
Taylor expanded in y around 0 91.8%
if 2.70000000000000016e-25 < y < 4.30000000000000025e173Initial program 73.9%
*-commutative73.9%
+-commutative73.9%
+-commutative73.9%
+-commutative73.9%
times-frac95.4%
+-commutative95.4%
+-commutative95.4%
+-commutative95.4%
associate-+l+95.4%
Simplified95.4%
Taylor expanded in x around 0 82.2%
+-commutative82.2%
Simplified82.2%
if 4.30000000000000025e173 < y Initial program 64.3%
associate-+r+64.3%
*-commutative64.3%
frac-times76.5%
associate-*l/76.5%
times-frac99.8%
Applied egg-rr99.8%
clear-num99.8%
frac-times99.8%
*-un-lft-identity99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+l+99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
Taylor expanded in y around inf 94.3%
*-commutative94.2%
Simplified94.3%
Final simplification72.6%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= x -1.04e+155)
(/ (/ y (+ y x)) (+ x (+ y (+ y 1.0))))
(if (<= x -5e-124)
(* (/ x (+ x (+ y 1.0))) (/ y (* (+ y x) (+ y x))))
(/ (/ x (+ y 1.0)) (* (+ y x) (/ (+ y x) y))))))assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.04e+155) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else if (x <= -5e-124) {
tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x)));
} else {
tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.04d+155)) then
tmp = (y / (y + x)) / (x + (y + (y + 1.0d0)))
else if (x <= (-5d-124)) then
tmp = (x / (x + (y + 1.0d0))) * (y / ((y + x) * (y + x)))
else
tmp = (x / (y + 1.0d0)) / ((y + x) * ((y + x) / y))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1.04e+155) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else if (x <= -5e-124) {
tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x)));
} else {
tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1.04e+155: tmp = (y / (y + x)) / (x + (y + (y + 1.0))) elif x <= -5e-124: tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x))) else: tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.04e+155) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + Float64(y + Float64(y + 1.0)))); elseif (x <= -5e-124) tmp = Float64(Float64(x / Float64(x + Float64(y + 1.0))) * Float64(y / Float64(Float64(y + x) * Float64(y + x)))); else tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(Float64(y + x) * Float64(Float64(y + x) / y))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1.04e+155)
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
elseif (x <= -5e-124)
tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x)));
else
tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.04e+155], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -5e-124], N[(N[(x / N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.04 \cdot 10^{+155}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + \left(y + \left(y + 1\right)\right)}\\
\mathbf{elif}\;x \leq -5 \cdot 10^{-124}:\\
\;\;\;\;\frac{x}{x + \left(y + 1\right)} \cdot \frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{\left(y + x\right) \cdot \frac{y + x}{y}}\\
\end{array}
\end{array}
if x < -1.03999999999999996e155Initial program 53.8%
+-commutative53.8%
+-commutative53.8%
+-commutative53.8%
associate-*l/79.4%
*-commutative79.4%
*-commutative79.4%
distribute-rgt1-in3.4%
fma-define79.4%
+-commutative79.4%
+-commutative79.4%
cube-unmult79.4%
+-commutative79.4%
Simplified79.4%
associate-*r/53.8%
fma-undefine0.0%
cube-mult0.0%
distribute-rgt1-in53.8%
associate-+r+53.8%
*-commutative53.8%
frac-times79.4%
*-commutative79.4%
associate-/r*99.9%
clear-num99.8%
frac-times97.8%
*-un-lft-identity97.8%
Applied egg-rr97.8%
Taylor expanded in x around -inf 83.0%
mul-1-neg83.0%
unsub-neg83.0%
neg-mul-183.0%
+-commutative83.0%
unsub-neg83.0%
distribute-lft-in83.0%
metadata-eval83.0%
neg-mul-183.0%
unsub-neg83.0%
Simplified83.0%
if -1.03999999999999996e155 < x < -5.0000000000000003e-124Initial program 76.5%
*-commutative76.5%
+-commutative76.5%
+-commutative76.5%
+-commutative76.5%
times-frac95.6%
+-commutative95.6%
+-commutative95.6%
+-commutative95.6%
associate-+l+95.6%
Simplified95.6%
if -5.0000000000000003e-124 < x Initial program 72.3%
associate-+r+72.3%
*-commutative72.3%
frac-times85.6%
associate-*l/81.3%
times-frac99.9%
Applied egg-rr99.9%
clear-num99.5%
frac-times99.0%
*-un-lft-identity99.0%
associate-+r+99.0%
+-commutative99.0%
associate-+l+99.0%
+-commutative99.0%
+-commutative99.0%
Applied egg-rr99.0%
Taylor expanded in x around 0 90.7%
+-commutative90.7%
Simplified90.7%
Final simplification91.2%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= x -1.15e+155)
(* (/ y (+ y x)) (/ 1.0 x))
(if (<= x -950000.0)
(/ y (* (+ y x) (+ y x)))
(if (<= x -9.5e-108) (/ y (* x (+ x 1.0))) (/ (/ x (+ y (+ x 1.0))) y)))))assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.15e+155) {
tmp = (y / (y + x)) * (1.0 / x);
} else if (x <= -950000.0) {
tmp = y / ((y + x) * (y + x));
} else if (x <= -9.5e-108) {
tmp = y / (x * (x + 1.0));
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.15d+155)) then
tmp = (y / (y + x)) * (1.0d0 / x)
else if (x <= (-950000.0d0)) then
tmp = y / ((y + x) * (y + x))
else if (x <= (-9.5d-108)) then
tmp = y / (x * (x + 1.0d0))
else
tmp = (x / (y + (x + 1.0d0))) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1.15e+155) {
tmp = (y / (y + x)) * (1.0 / x);
} else if (x <= -950000.0) {
tmp = y / ((y + x) * (y + x));
} else if (x <= -9.5e-108) {
tmp = y / (x * (x + 1.0));
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1.15e+155: tmp = (y / (y + x)) * (1.0 / x) elif x <= -950000.0: tmp = y / ((y + x) * (y + x)) elif x <= -9.5e-108: tmp = y / (x * (x + 1.0)) else: tmp = (x / (y + (x + 1.0))) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.15e+155) tmp = Float64(Float64(y / Float64(y + x)) * Float64(1.0 / x)); elseif (x <= -950000.0) tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x))); elseif (x <= -9.5e-108) tmp = Float64(y / Float64(x * Float64(x + 1.0))); else tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1.15e+155)
tmp = (y / (y + x)) * (1.0 / x);
elseif (x <= -950000.0)
tmp = y / ((y + x) * (y + x));
elseif (x <= -9.5e-108)
tmp = y / (x * (x + 1.0));
else
tmp = (x / (y + (x + 1.0))) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.15e+155], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -950000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -9.5e-108], N[(y / N[(x * N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.15 \cdot 10^{+155}:\\
\;\;\;\;\frac{y}{y + x} \cdot \frac{1}{x}\\
\mathbf{elif}\;x \leq -950000:\\
\;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\
\mathbf{elif}\;x \leq -9.5 \cdot 10^{-108}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y}\\
\end{array}
\end{array}
if x < -1.14999999999999999e155Initial program 53.8%
associate-+r+53.8%
*-commutative53.8%
frac-times79.4%
associate-*l/79.4%
times-frac99.8%
Applied egg-rr99.8%
Taylor expanded in x around inf 82.8%
if -1.14999999999999999e155 < x < -9.5e5Initial program 53.5%
*-commutative53.5%
+-commutative53.5%
+-commutative53.5%
+-commutative53.5%
times-frac88.8%
+-commutative88.8%
+-commutative88.8%
+-commutative88.8%
associate-+l+88.8%
Simplified88.8%
Taylor expanded in x around inf 73.8%
if -9.5e5 < x < -9.5000000000000005e-108Initial program 91.4%
*-commutative91.4%
+-commutative91.4%
+-commutative91.4%
+-commutative91.4%
times-frac99.6%
+-commutative99.6%
+-commutative99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in y around 0 54.3%
if -9.5000000000000005e-108 < x Initial program 72.6%
associate-+r+72.6%
*-commutative72.6%
frac-times86.1%
associate-*l/81.3%
times-frac99.9%
Applied egg-rr99.9%
clear-num99.5%
frac-times99.1%
*-un-lft-identity99.1%
associate-+r+99.1%
+-commutative99.1%
associate-+l+99.1%
+-commutative99.1%
+-commutative99.1%
Applied egg-rr99.1%
Taylor expanded in y around inf 61.6%
Final simplification64.0%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 3.8e-229)
(/ (/ y (+ y x)) (+ x 1.0))
(if (<= y 1.1e-11)
(/ x (* (+ y x) (/ (+ y x) y)))
(/ (/ x (+ y (+ x 1.0))) (+ y (* x 2.0))))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 3.8e-229) {
tmp = (y / (y + x)) / (x + 1.0);
} else if (y <= 1.1e-11) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 3.8d-229) then
tmp = (y / (y + x)) / (x + 1.0d0)
else if (y <= 1.1d-11) then
tmp = x / ((y + x) * ((y + x) / y))
else
tmp = (x / (y + (x + 1.0d0))) / (y + (x * 2.0d0))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 3.8e-229) {
tmp = (y / (y + x)) / (x + 1.0);
} else if (y <= 1.1e-11) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 3.8e-229: tmp = (y / (y + x)) / (x + 1.0) elif y <= 1.1e-11: tmp = x / ((y + x) * ((y + x) / y)) else: tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 3.8e-229) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + 1.0)); elseif (y <= 1.1e-11) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) / y))); else tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + Float64(x * 2.0))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 3.8e-229)
tmp = (y / (y + x)) / (x + 1.0);
elseif (y <= 1.1e-11)
tmp = x / ((y + x) * ((y + x) / y));
else
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 3.8e-229], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.1e-11], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.8 \cdot 10^{-229}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + 1}\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{-11}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \frac{y + x}{y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y + x \cdot 2}\\
\end{array}
\end{array}
if y < 3.8000000000000002e-229Initial program 70.2%
+-commutative70.2%
+-commutative70.2%
+-commutative70.2%
associate-*l/81.5%
*-commutative81.5%
*-commutative81.5%
distribute-rgt1-in54.2%
fma-define81.5%
+-commutative81.5%
+-commutative81.5%
cube-unmult81.5%
+-commutative81.5%
Simplified81.5%
associate-*r/70.3%
fma-undefine50.7%
cube-mult50.7%
distribute-rgt1-in70.2%
associate-+r+70.2%
*-commutative70.2%
frac-times87.1%
*-commutative87.1%
associate-/r*99.8%
clear-num99.8%
frac-times99.1%
*-un-lft-identity99.1%
Applied egg-rr99.1%
Taylor expanded in y around 0 57.8%
+-commutative57.8%
Simplified57.8%
if 3.8000000000000002e-229 < y < 1.1000000000000001e-11Initial program 78.9%
associate-+r+78.9%
*-commutative78.9%
frac-times91.0%
associate-*l/82.9%
times-frac100.0%
Applied egg-rr100.0%
clear-num99.9%
frac-times99.8%
*-un-lft-identity99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+l+99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
Taylor expanded in x around 0 88.7%
+-commutative88.7%
Simplified88.7%
Taylor expanded in y around 0 88.6%
if 1.1000000000000001e-11 < y Initial program 68.9%
associate-+r+68.9%
*-commutative68.9%
frac-times86.3%
associate-*l/86.3%
times-frac99.8%
Applied egg-rr99.8%
clear-num99.8%
frac-times99.7%
*-un-lft-identity99.7%
associate-+r+99.7%
+-commutative99.7%
associate-+l+99.7%
+-commutative99.7%
+-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around inf 82.8%
*-commutative82.6%
Simplified82.8%
Final simplification70.4%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 5.6e-232)
(/ (/ y (+ y x)) (+ x (+ y (+ y 1.0))))
(if (<= y 9.5e-11)
(/ x (* (+ y x) (/ (+ y x) y)))
(/ (/ x (+ y (+ x 1.0))) (+ y (* x 2.0))))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 5.6e-232) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else if (y <= 9.5e-11) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 5.6d-232) then
tmp = (y / (y + x)) / (x + (y + (y + 1.0d0)))
else if (y <= 9.5d-11) then
tmp = x / ((y + x) * ((y + x) / y))
else
tmp = (x / (y + (x + 1.0d0))) / (y + (x * 2.0d0))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 5.6e-232) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else if (y <= 9.5e-11) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 5.6e-232: tmp = (y / (y + x)) / (x + (y + (y + 1.0))) elif y <= 9.5e-11: tmp = x / ((y + x) * ((y + x) / y)) else: tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 5.6e-232) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + Float64(y + Float64(y + 1.0)))); elseif (y <= 9.5e-11) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) / y))); else tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + Float64(x * 2.0))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 5.6e-232)
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
elseif (y <= 9.5e-11)
tmp = x / ((y + x) * ((y + x) / y));
else
tmp = (x / (y + (x + 1.0))) / (y + (x * 2.0));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 5.6e-232], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.5e-11], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 5.6 \cdot 10^{-232}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + \left(y + \left(y + 1\right)\right)}\\
\mathbf{elif}\;y \leq 9.5 \cdot 10^{-11}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \frac{y + x}{y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y + x \cdot 2}\\
\end{array}
\end{array}
if y < 5.59999999999999985e-232Initial program 70.2%
+-commutative70.2%
+-commutative70.2%
+-commutative70.2%
associate-*l/81.5%
*-commutative81.5%
*-commutative81.5%
distribute-rgt1-in54.2%
fma-define81.5%
+-commutative81.5%
+-commutative81.5%
cube-unmult81.5%
+-commutative81.5%
Simplified81.5%
associate-*r/70.3%
fma-undefine50.7%
cube-mult50.7%
distribute-rgt1-in70.2%
associate-+r+70.2%
*-commutative70.2%
frac-times87.1%
*-commutative87.1%
associate-/r*99.8%
clear-num99.8%
frac-times99.1%
*-un-lft-identity99.1%
Applied egg-rr99.1%
Taylor expanded in x around -inf 58.6%
mul-1-neg58.6%
unsub-neg58.6%
neg-mul-158.6%
+-commutative58.6%
unsub-neg58.6%
distribute-lft-in58.6%
metadata-eval58.6%
neg-mul-158.6%
unsub-neg58.6%
Simplified58.6%
if 5.59999999999999985e-232 < y < 9.49999999999999951e-11Initial program 79.3%
associate-+r+79.3%
*-commutative79.3%
frac-times91.2%
associate-*l/83.2%
times-frac100.0%
Applied egg-rr100.0%
clear-num99.9%
frac-times99.8%
*-un-lft-identity99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+l+99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
Taylor expanded in x around 0 88.9%
+-commutative88.9%
Simplified88.9%
Taylor expanded in y around 0 88.9%
if 9.49999999999999951e-11 < y Initial program 68.5%
associate-+r+68.5%
*-commutative68.5%
frac-times86.1%
associate-*l/86.1%
times-frac99.8%
Applied egg-rr99.8%
clear-num99.8%
frac-times99.7%
*-un-lft-identity99.7%
associate-+r+99.7%
+-commutative99.7%
associate-+l+99.7%
+-commutative99.7%
+-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around inf 83.9%
*-commutative83.7%
Simplified83.9%
Final simplification71.2%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= x -1.0)
(* (/ 1.0 x) (/ y x))
(if (<= x -2.2e-108)
(- (/ y x) y)
(if (<= x 2.45e-171) (/ x y) (* (/ x y) (/ 1.0 y))))))assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.0) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -2.2e-108) {
tmp = (y / x) - y;
} else if (x <= 2.45e-171) {
tmp = x / y;
} else {
tmp = (x / y) * (1.0 / y);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.0d0)) then
tmp = (1.0d0 / x) * (y / x)
else if (x <= (-2.2d-108)) then
tmp = (y / x) - y
else if (x <= 2.45d-171) then
tmp = x / y
else
tmp = (x / y) * (1.0d0 / y)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1.0) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -2.2e-108) {
tmp = (y / x) - y;
} else if (x <= 2.45e-171) {
tmp = x / y;
} else {
tmp = (x / y) * (1.0 / y);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1.0: tmp = (1.0 / x) * (y / x) elif x <= -2.2e-108: tmp = (y / x) - y elif x <= 2.45e-171: tmp = x / y else: tmp = (x / y) * (1.0 / y) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.0) tmp = Float64(Float64(1.0 / x) * Float64(y / x)); elseif (x <= -2.2e-108) tmp = Float64(Float64(y / x) - y); elseif (x <= 2.45e-171) tmp = Float64(x / y); else tmp = Float64(Float64(x / y) * Float64(1.0 / y)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1.0)
tmp = (1.0 / x) * (y / x);
elseif (x <= -2.2e-108)
tmp = (y / x) - y;
elseif (x <= 2.45e-171)
tmp = x / y;
else
tmp = (x / y) * (1.0 / y);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.0], N[(N[(1.0 / x), $MachinePrecision] * N[(y / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.2e-108], N[(N[(y / x), $MachinePrecision] - y), $MachinePrecision], If[LessEqual[x, 2.45e-171], N[(x / y), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1:\\
\;\;\;\;\frac{1}{x} \cdot \frac{y}{x}\\
\mathbf{elif}\;x \leq -2.2 \cdot 10^{-108}:\\
\;\;\;\;\frac{y}{x} - y\\
\mathbf{elif}\;x \leq 2.45 \cdot 10^{-171}:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{y}\\
\end{array}
\end{array}
if x < -1Initial program 55.4%
associate-+r+55.4%
*-commutative55.4%
frac-times84.5%
associate-*l/84.5%
times-frac99.7%
Applied egg-rr99.7%
Taylor expanded in x around inf 70.8%
Taylor expanded in y around 0 70.5%
if -1 < x < -2.2000000000000001e-108Initial program 90.9%
*-commutative90.9%
+-commutative90.9%
+-commutative90.9%
+-commutative90.9%
times-frac99.6%
+-commutative99.6%
+-commutative99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in y around 0 51.7%
associate-/r*51.6%
+-commutative51.6%
Simplified51.6%
Taylor expanded in x around 0 50.8%
neg-mul-150.8%
+-commutative50.8%
unsub-neg50.8%
Simplified50.8%
if -2.2000000000000001e-108 < x < 2.44999999999999991e-171Initial program 70.8%
*-commutative70.8%
+-commutative70.8%
+-commutative70.8%
+-commutative70.8%
times-frac78.5%
+-commutative78.5%
+-commutative78.5%
+-commutative78.5%
associate-+l+78.5%
Simplified78.5%
Taylor expanded in x around 0 85.7%
+-commutative85.7%
Simplified85.7%
Taylor expanded in y around 0 71.6%
if 2.44999999999999991e-171 < x Initial program 74.2%
*-commutative74.2%
+-commutative74.2%
+-commutative74.2%
+-commutative74.2%
times-frac92.7%
+-commutative92.7%
+-commutative92.7%
+-commutative92.7%
associate-+l+92.7%
Simplified92.7%
Taylor expanded in x around 0 37.0%
+-commutative37.0%
Simplified37.0%
associate-/r*40.1%
div-inv40.1%
Applied egg-rr40.1%
Taylor expanded in y around inf 34.4%
Final simplification55.6%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 4.2e-232)
(/ (/ y (+ y x)) (+ x 1.0))
(if (<= y 3.9e-11)
(/ x (* (+ y x) (/ (+ y x) y)))
(/ (/ x (+ y (+ x 1.0))) y))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 4.2e-232) {
tmp = (y / (y + x)) / (x + 1.0);
} else if (y <= 3.9e-11) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 4.2d-232) then
tmp = (y / (y + x)) / (x + 1.0d0)
else if (y <= 3.9d-11) then
tmp = x / ((y + x) * ((y + x) / y))
else
tmp = (x / (y + (x + 1.0d0))) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 4.2e-232) {
tmp = (y / (y + x)) / (x + 1.0);
} else if (y <= 3.9e-11) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 4.2e-232: tmp = (y / (y + x)) / (x + 1.0) elif y <= 3.9e-11: tmp = x / ((y + x) * ((y + x) / y)) else: tmp = (x / (y + (x + 1.0))) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 4.2e-232) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + 1.0)); elseif (y <= 3.9e-11) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) / y))); else tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 4.2e-232)
tmp = (y / (y + x)) / (x + 1.0);
elseif (y <= 3.9e-11)
tmp = x / ((y + x) * ((y + x) / y));
else
tmp = (x / (y + (x + 1.0))) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 4.2e-232], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.9e-11], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 4.2 \cdot 10^{-232}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + 1}\\
\mathbf{elif}\;y \leq 3.9 \cdot 10^{-11}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \frac{y + x}{y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y}\\
\end{array}
\end{array}
if y < 4.2000000000000001e-232Initial program 70.2%
+-commutative70.2%
+-commutative70.2%
+-commutative70.2%
associate-*l/81.5%
*-commutative81.5%
*-commutative81.5%
distribute-rgt1-in54.2%
fma-define81.5%
+-commutative81.5%
+-commutative81.5%
cube-unmult81.5%
+-commutative81.5%
Simplified81.5%
associate-*r/70.3%
fma-undefine50.7%
cube-mult50.7%
distribute-rgt1-in70.2%
associate-+r+70.2%
*-commutative70.2%
frac-times87.1%
*-commutative87.1%
associate-/r*99.8%
clear-num99.8%
frac-times99.1%
*-un-lft-identity99.1%
Applied egg-rr99.1%
Taylor expanded in y around 0 57.8%
+-commutative57.8%
Simplified57.8%
if 4.2000000000000001e-232 < y < 3.9000000000000001e-11Initial program 78.9%
associate-+r+78.9%
*-commutative78.9%
frac-times91.0%
associate-*l/82.9%
times-frac100.0%
Applied egg-rr100.0%
clear-num99.9%
frac-times99.8%
*-un-lft-identity99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+l+99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
Taylor expanded in x around 0 88.7%
+-commutative88.7%
Simplified88.7%
Taylor expanded in y around 0 88.6%
if 3.9000000000000001e-11 < y Initial program 68.9%
associate-+r+68.9%
*-commutative68.9%
frac-times86.3%
associate-*l/86.3%
times-frac99.8%
Applied egg-rr99.8%
clear-num99.8%
frac-times99.7%
*-un-lft-identity99.7%
associate-+r+99.7%
+-commutative99.7%
associate-+l+99.7%
+-commutative99.7%
+-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around inf 82.6%
Final simplification70.3%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 3.8e-229)
(/ (/ y (+ y x)) (+ x 1.0))
(if (<= y 1e-10)
(/ x (* (+ y x) (/ (+ y x) y)))
(/ (/ x (+ y 1.0)) (+ y (* x 2.0))))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 3.8e-229) {
tmp = (y / (y + x)) / (x + 1.0);
} else if (y <= 1e-10) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + 1.0)) / (y + (x * 2.0));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 3.8d-229) then
tmp = (y / (y + x)) / (x + 1.0d0)
else if (y <= 1d-10) then
tmp = x / ((y + x) * ((y + x) / y))
else
tmp = (x / (y + 1.0d0)) / (y + (x * 2.0d0))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 3.8e-229) {
tmp = (y / (y + x)) / (x + 1.0);
} else if (y <= 1e-10) {
tmp = x / ((y + x) * ((y + x) / y));
} else {
tmp = (x / (y + 1.0)) / (y + (x * 2.0));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 3.8e-229: tmp = (y / (y + x)) / (x + 1.0) elif y <= 1e-10: tmp = x / ((y + x) * ((y + x) / y)) else: tmp = (x / (y + 1.0)) / (y + (x * 2.0)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 3.8e-229) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + 1.0)); elseif (y <= 1e-10) tmp = Float64(x / Float64(Float64(y + x) * Float64(Float64(y + x) / y))); else tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + Float64(x * 2.0))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 3.8e-229)
tmp = (y / (y + x)) / (x + 1.0);
elseif (y <= 1e-10)
tmp = x / ((y + x) * ((y + x) / y));
else
tmp = (x / (y + 1.0)) / (y + (x * 2.0));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 3.8e-229], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1e-10], N[(x / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.8 \cdot 10^{-229}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + 1}\\
\mathbf{elif}\;y \leq 10^{-10}:\\
\;\;\;\;\frac{x}{\left(y + x\right) \cdot \frac{y + x}{y}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y + x \cdot 2}\\
\end{array}
\end{array}
if y < 3.8000000000000002e-229Initial program 70.2%
+-commutative70.2%
+-commutative70.2%
+-commutative70.2%
associate-*l/81.5%
*-commutative81.5%
*-commutative81.5%
distribute-rgt1-in54.2%
fma-define81.5%
+-commutative81.5%
+-commutative81.5%
cube-unmult81.5%
+-commutative81.5%
Simplified81.5%
associate-*r/70.3%
fma-undefine50.7%
cube-mult50.7%
distribute-rgt1-in70.2%
associate-+r+70.2%
*-commutative70.2%
frac-times87.1%
*-commutative87.1%
associate-/r*99.8%
clear-num99.8%
frac-times99.1%
*-un-lft-identity99.1%
Applied egg-rr99.1%
Taylor expanded in y around 0 57.8%
+-commutative57.8%
Simplified57.8%
if 3.8000000000000002e-229 < y < 1.00000000000000004e-10Initial program 79.3%
associate-+r+79.3%
*-commutative79.3%
frac-times91.2%
associate-*l/83.2%
times-frac100.0%
Applied egg-rr100.0%
clear-num99.9%
frac-times99.8%
*-un-lft-identity99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+l+99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
Taylor expanded in x around 0 88.9%
+-commutative88.9%
Simplified88.9%
Taylor expanded in y around 0 88.9%
if 1.00000000000000004e-10 < y Initial program 68.5%
associate-+r+68.5%
*-commutative68.5%
frac-times86.1%
associate-*l/86.1%
times-frac99.8%
Applied egg-rr99.8%
clear-num99.8%
frac-times99.7%
*-un-lft-identity99.7%
associate-+r+99.7%
+-commutative99.7%
associate-+l+99.7%
+-commutative99.7%
+-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in x around 0 89.1%
+-commutative89.1%
Simplified89.1%
Taylor expanded in y around inf 83.7%
*-commutative83.7%
Simplified83.7%
Final simplification70.7%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= y 4e-232) (/ (/ y (+ y x)) (+ x (+ y (+ y 1.0)))) (/ (/ x (+ y 1.0)) (* (+ y x) (/ (+ y x) y)))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 4e-232) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else {
tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 4d-232) then
tmp = (y / (y + x)) / (x + (y + (y + 1.0d0)))
else
tmp = (x / (y + 1.0d0)) / ((y + x) * ((y + x) / y))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 4e-232) {
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
} else {
tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 4e-232: tmp = (y / (y + x)) / (x + (y + (y + 1.0))) else: tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 4e-232) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + Float64(y + Float64(y + 1.0)))); else tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(Float64(y + x) * Float64(Float64(y + x) / y))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 4e-232)
tmp = (y / (y + x)) / (x + (y + (y + 1.0)));
else
tmp = (x / (y + 1.0)) / ((y + x) * ((y + x) / y));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 4e-232], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(N[(y + x), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 4 \cdot 10^{-232}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + \left(y + \left(y + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{\left(y + x\right) \cdot \frac{y + x}{y}}\\
\end{array}
\end{array}
if y < 4.0000000000000001e-232Initial program 70.2%
+-commutative70.2%
+-commutative70.2%
+-commutative70.2%
associate-*l/81.5%
*-commutative81.5%
*-commutative81.5%
distribute-rgt1-in54.2%
fma-define81.5%
+-commutative81.5%
+-commutative81.5%
cube-unmult81.5%
+-commutative81.5%
Simplified81.5%
associate-*r/70.3%
fma-undefine50.7%
cube-mult50.7%
distribute-rgt1-in70.2%
associate-+r+70.2%
*-commutative70.2%
frac-times87.1%
*-commutative87.1%
associate-/r*99.8%
clear-num99.8%
frac-times99.1%
*-un-lft-identity99.1%
Applied egg-rr99.1%
Taylor expanded in x around -inf 58.6%
mul-1-neg58.6%
unsub-neg58.6%
neg-mul-158.6%
+-commutative58.6%
unsub-neg58.6%
distribute-lft-in58.6%
metadata-eval58.6%
neg-mul-158.6%
unsub-neg58.6%
Simplified58.6%
if 4.0000000000000001e-232 < y Initial program 72.9%
associate-+r+72.9%
*-commutative72.9%
frac-times88.2%
associate-*l/84.9%
times-frac99.9%
Applied egg-rr99.9%
clear-num99.9%
frac-times99.7%
*-un-lft-identity99.7%
associate-+r+99.7%
+-commutative99.7%
associate-+l+99.7%
+-commutative99.7%
+-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in x around 0 89.0%
+-commutative89.0%
Simplified89.0%
Final simplification72.6%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= y 8.2e-118) (/ y x) (if (<= y 1.6) (- (/ x y) x) (* (/ x y) (/ 1.0 y)))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 8.2e-118) {
tmp = y / x;
} else if (y <= 1.6) {
tmp = (x / y) - x;
} else {
tmp = (x / y) * (1.0 / y);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 8.2d-118) then
tmp = y / x
else if (y <= 1.6d0) then
tmp = (x / y) - x
else
tmp = (x / y) * (1.0d0 / y)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 8.2e-118) {
tmp = y / x;
} else if (y <= 1.6) {
tmp = (x / y) - x;
} else {
tmp = (x / y) * (1.0 / y);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 8.2e-118: tmp = y / x elif y <= 1.6: tmp = (x / y) - x else: tmp = (x / y) * (1.0 / y) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 8.2e-118) tmp = Float64(y / x); elseif (y <= 1.6) tmp = Float64(Float64(x / y) - x); else tmp = Float64(Float64(x / y) * Float64(1.0 / y)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 8.2e-118)
tmp = y / x;
elseif (y <= 1.6)
tmp = (x / y) - x;
else
tmp = (x / y) * (1.0 / y);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 8.2e-118], N[(y / x), $MachinePrecision], If[LessEqual[y, 1.6], N[(N[(x / y), $MachinePrecision] - x), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 8.2 \cdot 10^{-118}:\\
\;\;\;\;\frac{y}{x}\\
\mathbf{elif}\;y \leq 1.6:\\
\;\;\;\;\frac{x}{y} - x\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} \cdot \frac{1}{y}\\
\end{array}
\end{array}
if y < 8.2000000000000006e-118Initial program 70.4%
associate-+r+70.4%
*-commutative70.4%
frac-times86.2%
associate-*l/80.8%
times-frac99.9%
Applied egg-rr99.9%
Taylor expanded in y around 0 60.8%
+-commutative60.8%
Simplified60.8%
Taylor expanded in x around 0 38.6%
if 8.2000000000000006e-118 < y < 1.6000000000000001Initial program 87.4%
*-commutative87.4%
+-commutative87.4%
+-commutative87.4%
+-commutative87.4%
times-frac99.6%
+-commutative99.6%
+-commutative99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in x around 0 47.3%
+-commutative47.3%
Simplified47.3%
Taylor expanded in y around 0 41.0%
neg-mul-141.0%
+-commutative41.0%
unsub-neg41.0%
Simplified41.0%
if 1.6000000000000001 < y Initial program 66.6%
*-commutative66.6%
+-commutative66.6%
+-commutative66.6%
+-commutative66.6%
times-frac85.3%
+-commutative85.3%
+-commutative85.3%
+-commutative85.3%
associate-+l+85.3%
Simplified85.3%
Taylor expanded in x around 0 75.1%
+-commutative75.1%
Simplified75.1%
associate-/r*82.5%
div-inv82.5%
Applied egg-rr82.5%
Taylor expanded in y around inf 81.4%
Final simplification49.9%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -1.0) (* (/ 1.0 x) (/ y x)) (if (<= x -1.7e-107) (- (/ y x) y) (/ x (* y (+ y 1.0))))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.0) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -1.7e-107) {
tmp = (y / x) - y;
} else {
tmp = x / (y * (y + 1.0));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.0d0)) then
tmp = (1.0d0 / x) * (y / x)
else if (x <= (-1.7d-107)) then
tmp = (y / x) - y
else
tmp = x / (y * (y + 1.0d0))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1.0) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -1.7e-107) {
tmp = (y / x) - y;
} else {
tmp = x / (y * (y + 1.0));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1.0: tmp = (1.0 / x) * (y / x) elif x <= -1.7e-107: tmp = (y / x) - y else: tmp = x / (y * (y + 1.0)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.0) tmp = Float64(Float64(1.0 / x) * Float64(y / x)); elseif (x <= -1.7e-107) tmp = Float64(Float64(y / x) - y); else tmp = Float64(x / Float64(y * Float64(y + 1.0))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1.0)
tmp = (1.0 / x) * (y / x);
elseif (x <= -1.7e-107)
tmp = (y / x) - y;
else
tmp = x / (y * (y + 1.0));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.0], N[(N[(1.0 / x), $MachinePrecision] * N[(y / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.7e-107], N[(N[(y / x), $MachinePrecision] - y), $MachinePrecision], N[(x / N[(y * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1:\\
\;\;\;\;\frac{1}{x} \cdot \frac{y}{x}\\
\mathbf{elif}\;x \leq -1.7 \cdot 10^{-107}:\\
\;\;\;\;\frac{y}{x} - y\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(y + 1\right)}\\
\end{array}
\end{array}
if x < -1Initial program 55.4%
associate-+r+55.4%
*-commutative55.4%
frac-times84.5%
associate-*l/84.5%
times-frac99.7%
Applied egg-rr99.7%
Taylor expanded in x around inf 70.8%
Taylor expanded in y around 0 70.5%
if -1 < x < -1.69999999999999997e-107Initial program 90.9%
*-commutative90.9%
+-commutative90.9%
+-commutative90.9%
+-commutative90.9%
times-frac99.6%
+-commutative99.6%
+-commutative99.6%
+-commutative99.6%
associate-+l+99.6%
Simplified99.6%
Taylor expanded in y around 0 51.7%
associate-/r*51.6%
+-commutative51.6%
Simplified51.6%
Taylor expanded in x around 0 50.8%
neg-mul-150.8%
+-commutative50.8%
unsub-neg50.8%
Simplified50.8%
if -1.69999999999999997e-107 < x Initial program 72.6%
*-commutative72.6%
+-commutative72.6%
+-commutative72.6%
+-commutative72.6%
times-frac86.1%
+-commutative86.1%
+-commutative86.1%
+-commutative86.1%
associate-+l+86.1%
Simplified86.1%
Taylor expanded in x around 0 59.7%
+-commutative59.7%
Simplified59.7%
Final simplification60.8%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -1e+115) (* (/ 1.0 x) (/ y x)) (if (<= x -1.8e-107) (/ y (* x (+ x 1.0))) (/ x (* y (+ y 1.0))))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1e+115) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -1.8e-107) {
tmp = y / (x * (x + 1.0));
} else {
tmp = x / (y * (y + 1.0));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1d+115)) then
tmp = (1.0d0 / x) * (y / x)
else if (x <= (-1.8d-107)) then
tmp = y / (x * (x + 1.0d0))
else
tmp = x / (y * (y + 1.0d0))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1e+115) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -1.8e-107) {
tmp = y / (x * (x + 1.0));
} else {
tmp = x / (y * (y + 1.0));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1e+115: tmp = (1.0 / x) * (y / x) elif x <= -1.8e-107: tmp = y / (x * (x + 1.0)) else: tmp = x / (y * (y + 1.0)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1e+115) tmp = Float64(Float64(1.0 / x) * Float64(y / x)); elseif (x <= -1.8e-107) tmp = Float64(y / Float64(x * Float64(x + 1.0))); else tmp = Float64(x / Float64(y * Float64(y + 1.0))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1e+115)
tmp = (1.0 / x) * (y / x);
elseif (x <= -1.8e-107)
tmp = y / (x * (x + 1.0));
else
tmp = x / (y * (y + 1.0));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1e+115], N[(N[(1.0 / x), $MachinePrecision] * N[(y / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.8e-107], N[(y / N[(x * N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1 \cdot 10^{+115}:\\
\;\;\;\;\frac{1}{x} \cdot \frac{y}{x}\\
\mathbf{elif}\;x \leq -1.8 \cdot 10^{-107}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(y + 1\right)}\\
\end{array}
\end{array}
if x < -1e115Initial program 50.3%
associate-+r+50.3%
*-commutative50.3%
frac-times79.9%
associate-*l/79.9%
times-frac99.9%
Applied egg-rr99.9%
Taylor expanded in x around inf 79.8%
Taylor expanded in y around 0 79.5%
if -1e115 < x < -1.79999999999999988e-107Initial program 82.9%
*-commutative82.9%
+-commutative82.9%
+-commutative82.9%
+-commutative82.9%
times-frac98.0%
+-commutative98.0%
+-commutative98.0%
+-commutative98.0%
associate-+l+98.0%
Simplified98.0%
Taylor expanded in y around 0 54.4%
if -1.79999999999999988e-107 < x Initial program 72.6%
*-commutative72.6%
+-commutative72.6%
+-commutative72.6%
+-commutative72.6%
times-frac86.1%
+-commutative86.1%
+-commutative86.1%
+-commutative86.1%
associate-+l+86.1%
Simplified86.1%
Taylor expanded in x around 0 59.7%
+-commutative59.7%
Simplified59.7%
Final simplification61.5%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -1e+115) (* (/ 1.0 x) (/ y x)) (if (<= x -1.8e-107) (/ y (* x (+ x 1.0))) (/ (/ x (+ y 1.0)) y))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1e+115) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -1.8e-107) {
tmp = y / (x * (x + 1.0));
} else {
tmp = (x / (y + 1.0)) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1d+115)) then
tmp = (1.0d0 / x) * (y / x)
else if (x <= (-1.8d-107)) then
tmp = y / (x * (x + 1.0d0))
else
tmp = (x / (y + 1.0d0)) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1e+115) {
tmp = (1.0 / x) * (y / x);
} else if (x <= -1.8e-107) {
tmp = y / (x * (x + 1.0));
} else {
tmp = (x / (y + 1.0)) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1e+115: tmp = (1.0 / x) * (y / x) elif x <= -1.8e-107: tmp = y / (x * (x + 1.0)) else: tmp = (x / (y + 1.0)) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1e+115) tmp = Float64(Float64(1.0 / x) * Float64(y / x)); elseif (x <= -1.8e-107) tmp = Float64(y / Float64(x * Float64(x + 1.0))); else tmp = Float64(Float64(x / Float64(y + 1.0)) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1e+115)
tmp = (1.0 / x) * (y / x);
elseif (x <= -1.8e-107)
tmp = y / (x * (x + 1.0));
else
tmp = (x / (y + 1.0)) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1e+115], N[(N[(1.0 / x), $MachinePrecision] * N[(y / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.8e-107], N[(y / N[(x * N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1 \cdot 10^{+115}:\\
\;\;\;\;\frac{1}{x} \cdot \frac{y}{x}\\
\mathbf{elif}\;x \leq -1.8 \cdot 10^{-107}:\\
\;\;\;\;\frac{y}{x \cdot \left(x + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y}\\
\end{array}
\end{array}
if x < -1e115Initial program 50.3%
associate-+r+50.3%
*-commutative50.3%
frac-times79.9%
associate-*l/79.9%
times-frac99.9%
Applied egg-rr99.9%
Taylor expanded in x around inf 79.8%
Taylor expanded in y around 0 79.5%
if -1e115 < x < -1.79999999999999988e-107Initial program 82.9%
*-commutative82.9%
+-commutative82.9%
+-commutative82.9%
+-commutative82.9%
times-frac98.0%
+-commutative98.0%
+-commutative98.0%
+-commutative98.0%
associate-+l+98.0%
Simplified98.0%
Taylor expanded in y around 0 54.4%
if -1.79999999999999988e-107 < x Initial program 72.6%
*-commutative72.6%
+-commutative72.6%
+-commutative72.6%
+-commutative72.6%
times-frac86.1%
+-commutative86.1%
+-commutative86.1%
+-commutative86.1%
associate-+l+86.1%
Simplified86.1%
Taylor expanded in x around 0 59.7%
+-commutative59.7%
Simplified59.7%
*-un-lft-identity59.7%
times-frac61.4%
Applied egg-rr61.4%
associate-*l/61.4%
*-lft-identity61.4%
Simplified61.4%
Final simplification62.6%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -1.8e-107) (/ (/ y x) (+ x 1.0)) (/ (/ x (+ y (+ x 1.0))) y)))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.8e-107) {
tmp = (y / x) / (x + 1.0);
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.8d-107)) then
tmp = (y / x) / (x + 1.0d0)
else
tmp = (x / (y + (x + 1.0d0))) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1.8e-107) {
tmp = (y / x) / (x + 1.0);
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1.8e-107: tmp = (y / x) / (x + 1.0) else: tmp = (x / (y + (x + 1.0))) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.8e-107) tmp = Float64(Float64(y / x) / Float64(x + 1.0)); else tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1.8e-107)
tmp = (y / x) / (x + 1.0);
else
tmp = (x / (y + (x + 1.0))) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.8e-107], N[(N[(y / x), $MachinePrecision] / N[(x + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.8 \cdot 10^{-107}:\\
\;\;\;\;\frac{\frac{y}{x}}{x + 1}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y}\\
\end{array}
\end{array}
if x < -1.79999999999999988e-107Initial program 69.4%
*-commutative69.4%
+-commutative69.4%
+-commutative69.4%
+-commutative69.4%
times-frac90.5%
+-commutative90.5%
+-commutative90.5%
+-commutative90.5%
associate-+l+90.5%
Simplified90.5%
Taylor expanded in y around 0 63.9%
associate-/r*64.8%
+-commutative64.8%
Simplified64.8%
if -1.79999999999999988e-107 < x Initial program 72.6%
associate-+r+72.6%
*-commutative72.6%
frac-times86.1%
associate-*l/81.3%
times-frac99.9%
Applied egg-rr99.9%
clear-num99.5%
frac-times99.1%
*-un-lft-identity99.1%
associate-+r+99.1%
+-commutative99.1%
associate-+l+99.1%
+-commutative99.1%
+-commutative99.1%
Applied egg-rr99.1%
Taylor expanded in y around inf 61.6%
Final simplification62.7%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -1.8e-107) (/ (/ y (+ y x)) (+ x 1.0)) (/ (/ x (+ y (+ x 1.0))) y)))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.8e-107) {
tmp = (y / (y + x)) / (x + 1.0);
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.8d-107)) then
tmp = (y / (y + x)) / (x + 1.0d0)
else
tmp = (x / (y + (x + 1.0d0))) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1.8e-107) {
tmp = (y / (y + x)) / (x + 1.0);
} else {
tmp = (x / (y + (x + 1.0))) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1.8e-107: tmp = (y / (y + x)) / (x + 1.0) else: tmp = (x / (y + (x + 1.0))) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.8e-107) tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + 1.0)); else tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1.8e-107)
tmp = (y / (y + x)) / (x + 1.0);
else
tmp = (x / (y + (x + 1.0))) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.8e-107], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.8 \cdot 10^{-107}:\\
\;\;\;\;\frac{\frac{y}{y + x}}{x + 1}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y}\\
\end{array}
\end{array}
if x < -1.79999999999999988e-107Initial program 69.4%
+-commutative69.4%
+-commutative69.4%
+-commutative69.4%
associate-*l/79.1%
*-commutative79.1%
*-commutative79.1%
distribute-rgt1-in50.4%
fma-define79.1%
+-commutative79.1%
+-commutative79.1%
cube-unmult79.1%
+-commutative79.1%
Simplified79.1%
associate-*r/69.4%
fma-undefine47.4%
cube-mult47.3%
distribute-rgt1-in69.4%
associate-+r+69.4%
*-commutative69.4%
frac-times90.5%
*-commutative90.5%
associate-/r*99.8%
clear-num99.7%
frac-times98.6%
*-un-lft-identity98.6%
Applied egg-rr98.6%
Taylor expanded in y around 0 65.1%
+-commutative65.1%
Simplified65.1%
if -1.79999999999999988e-107 < x Initial program 72.6%
associate-+r+72.6%
*-commutative72.6%
frac-times86.1%
associate-*l/81.3%
times-frac99.9%
Applied egg-rr99.9%
clear-num99.5%
frac-times99.1%
*-un-lft-identity99.1%
associate-+r+99.1%
+-commutative99.1%
associate-+l+99.1%
+-commutative99.1%
+-commutative99.1%
Applied egg-rr99.1%
Taylor expanded in y around inf 61.6%
Final simplification62.8%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -1.8e-107) (/ (/ y x) (+ x 1.0)) (/ (/ x (+ y 1.0)) y)))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.8e-107) {
tmp = (y / x) / (x + 1.0);
} else {
tmp = (x / (y + 1.0)) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.8d-107)) then
tmp = (y / x) / (x + 1.0d0)
else
tmp = (x / (y + 1.0d0)) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -1.8e-107) {
tmp = (y / x) / (x + 1.0);
} else {
tmp = (x / (y + 1.0)) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -1.8e-107: tmp = (y / x) / (x + 1.0) else: tmp = (x / (y + 1.0)) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.8e-107) tmp = Float64(Float64(y / x) / Float64(x + 1.0)); else tmp = Float64(Float64(x / Float64(y + 1.0)) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -1.8e-107)
tmp = (y / x) / (x + 1.0);
else
tmp = (x / (y + 1.0)) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.8e-107], N[(N[(y / x), $MachinePrecision] / N[(x + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.8 \cdot 10^{-107}:\\
\;\;\;\;\frac{\frac{y}{x}}{x + 1}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y + 1}}{y}\\
\end{array}
\end{array}
if x < -1.79999999999999988e-107Initial program 69.4%
*-commutative69.4%
+-commutative69.4%
+-commutative69.4%
+-commutative69.4%
times-frac90.5%
+-commutative90.5%
+-commutative90.5%
+-commutative90.5%
associate-+l+90.5%
Simplified90.5%
Taylor expanded in y around 0 63.9%
associate-/r*64.8%
+-commutative64.8%
Simplified64.8%
if -1.79999999999999988e-107 < x Initial program 72.6%
*-commutative72.6%
+-commutative72.6%
+-commutative72.6%
+-commutative72.6%
times-frac86.1%
+-commutative86.1%
+-commutative86.1%
+-commutative86.1%
associate-+l+86.1%
Simplified86.1%
Taylor expanded in x around 0 59.7%
+-commutative59.7%
Simplified59.7%
*-un-lft-identity59.7%
times-frac61.4%
Applied egg-rr61.4%
associate-*l/61.4%
*-lft-identity61.4%
Simplified61.4%
Final simplification62.6%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -6.6e-108) (/ y x) (/ x y)))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -6.6e-108) {
tmp = y / x;
} else {
tmp = x / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-6.6d-108)) then
tmp = y / x
else
tmp = x / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (x <= -6.6e-108) {
tmp = y / x;
} else {
tmp = x / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if x <= -6.6e-108: tmp = y / x else: tmp = x / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -6.6e-108) tmp = Float64(y / x); else tmp = Float64(x / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (x <= -6.6e-108)
tmp = y / x;
else
tmp = x / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -6.6e-108], N[(y / x), $MachinePrecision], N[(x / y), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6.6 \cdot 10^{-108}:\\
\;\;\;\;\frac{y}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y}\\
\end{array}
\end{array}
if x < -6.6000000000000004e-108Initial program 69.4%
associate-+r+69.4%
*-commutative69.4%
frac-times90.5%
associate-*l/87.6%
times-frac99.8%
Applied egg-rr99.8%
Taylor expanded in y around 0 63.9%
+-commutative63.9%
Simplified63.9%
Taylor expanded in x around 0 35.9%
if -6.6000000000000004e-108 < x Initial program 72.6%
*-commutative72.6%
+-commutative72.6%
+-commutative72.6%
+-commutative72.6%
times-frac86.1%
+-commutative86.1%
+-commutative86.1%
+-commutative86.1%
associate-+l+86.1%
Simplified86.1%
Taylor expanded in x around 0 59.7%
+-commutative59.7%
Simplified59.7%
Taylor expanded in y around 0 40.9%
Final simplification39.2%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (/ 1.0 x))
assert(x < y);
double code(double x, double y) {
return 1.0 / x;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 / x
end function
assert x < y;
public static double code(double x, double y) {
return 1.0 / x;
}
[x, y] = sort([x, y]) def code(x, y): return 1.0 / x
x, y = sort([x, y]) function code(x, y) return Float64(1.0 / x) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = 1.0 / x;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[(1.0 / x), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{1}{x}
\end{array}
Initial program 71.5%
associate-+r+71.5%
*-commutative71.5%
frac-times87.6%
associate-*l/83.5%
times-frac99.9%
Applied egg-rr99.9%
Taylor expanded in x around inf 31.2%
Taylor expanded in y around inf 3.9%
Final simplification3.9%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (/ x y))
assert(x < y);
double code(double x, double y) {
return x / y;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x / y
end function
assert x < y;
public static double code(double x, double y) {
return x / y;
}
[x, y] = sort([x, y]) def code(x, y): return x / y
x, y = sort([x, y]) function code(x, y) return Float64(x / y) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = x / y;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[(x / y), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{x}{y}
\end{array}
Initial program 71.5%
*-commutative71.5%
+-commutative71.5%
+-commutative71.5%
+-commutative71.5%
times-frac87.6%
+-commutative87.6%
+-commutative87.6%
+-commutative87.6%
associate-+l+87.6%
Simplified87.6%
Taylor expanded in x around 0 50.8%
+-commutative50.8%
Simplified50.8%
Taylor expanded in y around 0 28.8%
Final simplification28.8%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (- y))
assert(x < y);
double code(double x, double y) {
return -y;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = -y
end function
assert x < y;
public static double code(double x, double y) {
return -y;
}
[x, y] = sort([x, y]) def code(x, y): return -y
x, y = sort([x, y]) function code(x, y) return Float64(-y) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = -y;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := (-y)
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
-y
\end{array}
Initial program 71.5%
*-commutative71.5%
+-commutative71.5%
+-commutative71.5%
+-commutative71.5%
times-frac87.6%
+-commutative87.6%
+-commutative87.6%
+-commutative87.6%
associate-+l+87.6%
Simplified87.6%
Taylor expanded in y around 0 48.8%
associate-/r*49.0%
+-commutative49.0%
Simplified49.0%
Taylor expanded in x around 0 19.9%
neg-mul-119.9%
+-commutative19.9%
unsub-neg19.9%
Simplified19.9%
Taylor expanded in x around inf 3.6%
neg-mul-13.6%
Simplified3.6%
Final simplification3.6%
(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 2024034
(FPCore (x y)
:name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, A"
:precision binary64
:herbie-target
(/ (/ (/ x (+ (+ y 1.0) x)) (+ y x)) (/ 1.0 (/ y (+ y x))))
(/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))