
(FPCore (x y) :precision binary64 (- 1.0 (log (- 1.0 (/ (- x y) (- 1.0 y))))))
double code(double x, double y) {
return 1.0 - log((1.0 - ((x - y) / (1.0 - y))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 - log((1.0d0 - ((x - y) / (1.0d0 - y))))
end function
public static double code(double x, double y) {
return 1.0 - Math.log((1.0 - ((x - y) / (1.0 - y))));
}
def code(x, y): return 1.0 - math.log((1.0 - ((x - y) / (1.0 - y))))
function code(x, y) return Float64(1.0 - log(Float64(1.0 - Float64(Float64(x - y) / Float64(1.0 - y))))) end
function tmp = code(x, y) tmp = 1.0 - log((1.0 - ((x - y) / (1.0 - y)))); end
code[x_, y_] := N[(1.0 - N[Log[N[(1.0 - N[(N[(x - y), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \log \left(1 - \frac{x - y}{1 - y}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (- 1.0 (log (- 1.0 (/ (- x y) (- 1.0 y))))))
double code(double x, double y) {
return 1.0 - log((1.0 - ((x - y) / (1.0 - y))));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 - log((1.0d0 - ((x - y) / (1.0d0 - y))))
end function
public static double code(double x, double y) {
return 1.0 - Math.log((1.0 - ((x - y) / (1.0 - y))));
}
def code(x, y): return 1.0 - math.log((1.0 - ((x - y) / (1.0 - y))))
function code(x, y) return Float64(1.0 - log(Float64(1.0 - Float64(Float64(x - y) / Float64(1.0 - y))))) end
function tmp = code(x, y) tmp = 1.0 - log((1.0 - ((x - y) / (1.0 - y)))); end
code[x_, y_] := N[(1.0 - N[Log[N[(1.0 - N[(N[(x - y), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \log \left(1 - \frac{x - y}{1 - y}\right)
\end{array}
(FPCore (x y) :precision binary64 (log (* (/ E (- 1.0 x)) (- 1.0 y))))
double code(double x, double y) {
return log(((((double) M_E) / (1.0 - x)) * (1.0 - y)));
}
public static double code(double x, double y) {
return Math.log(((Math.E / (1.0 - x)) * (1.0 - y)));
}
def code(x, y): return math.log(((math.e / (1.0 - x)) * (1.0 - y)))
function code(x, y) return log(Float64(Float64(exp(1) / Float64(1.0 - x)) * Float64(1.0 - y))) end
function tmp = code(x, y) tmp = log(((2.71828182845904523536 / (1.0 - x)) * (1.0 - y))); end
code[x_, y_] := N[Log[N[(N[(E / N[(1.0 - x), $MachinePrecision]), $MachinePrecision] * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(\frac{e}{1 - x} \cdot \left(1 - y\right)\right)
\end{array}
Initial program 74.1%
sub-neg74.1%
log1p-def74.1%
distribute-neg-frac74.1%
sub-neg74.1%
distribute-neg-in74.1%
remove-double-neg74.1%
+-commutative74.1%
sub-neg74.1%
Simplified74.1%
add-log-exp74.1%
exp-diff74.1%
exp-1-e74.1%
log1p-udef74.1%
add-exp-log74.1%
Applied egg-rr74.1%
Taylor expanded in y around 0 83.7%
+-commutative83.7%
mul-1-neg83.7%
unsub-neg83.7%
associate-/l*83.7%
*-commutative83.7%
associate-/r*89.9%
sub-neg89.9%
mul-1-neg89.9%
unpow289.9%
associate-/l*100.0%
mul-1-neg100.0%
sub-neg100.0%
*-inverses100.0%
Simplified100.0%
Taylor expanded in y around 0 99.6%
*-rgt-identity99.6%
mul-1-neg99.6%
associate-*l/100.0%
distribute-rgt-neg-out100.0%
distribute-lft-out100.0%
unsub-neg100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (<= (/ (- x y) (- 1.0 y)) 0.998) (- 1.0 (log1p (* (/ 1.0 (- 1.0 y)) (- y x)))) (log (/ E (/ (+ x -1.0) y)))))
double code(double x, double y) {
double tmp;
if (((x - y) / (1.0 - y)) <= 0.998) {
tmp = 1.0 - log1p(((1.0 / (1.0 - y)) * (y - x)));
} else {
tmp = log((((double) M_E) / ((x + -1.0) / y)));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (((x - y) / (1.0 - y)) <= 0.998) {
tmp = 1.0 - Math.log1p(((1.0 / (1.0 - y)) * (y - x)));
} else {
tmp = Math.log((Math.E / ((x + -1.0) / y)));
}
return tmp;
}
def code(x, y): tmp = 0 if ((x - y) / (1.0 - y)) <= 0.998: tmp = 1.0 - math.log1p(((1.0 / (1.0 - y)) * (y - x))) else: tmp = math.log((math.e / ((x + -1.0) / y))) return tmp
function code(x, y) tmp = 0.0 if (Float64(Float64(x - y) / Float64(1.0 - y)) <= 0.998) tmp = Float64(1.0 - log1p(Float64(Float64(1.0 / Float64(1.0 - y)) * Float64(y - x)))); else tmp = log(Float64(exp(1) / Float64(Float64(x + -1.0) / y))); end return tmp end
code[x_, y_] := If[LessEqual[N[(N[(x - y), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision], 0.998], N[(1.0 - N[Log[1 + N[(N[(1.0 / N[(1.0 - y), $MachinePrecision]), $MachinePrecision] * N[(y - x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Log[N[(E / N[(N[(x + -1.0), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x - y}{1 - y} \leq 0.998:\\
\;\;\;\;1 - \mathsf{log1p}\left(\frac{1}{1 - y} \cdot \left(y - x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\log \left(\frac{e}{\frac{x + -1}{y}}\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 x y) (-.f64 1 y)) < 0.998Initial program 99.9%
sub-neg99.9%
log1p-def99.9%
distribute-neg-frac99.9%
sub-neg99.9%
distribute-neg-in99.9%
remove-double-neg99.9%
+-commutative99.9%
sub-neg99.9%
Simplified99.9%
clear-num99.9%
associate-/r/99.9%
Applied egg-rr99.9%
if 0.998 < (/.f64 (-.f64 x y) (-.f64 1 y)) Initial program 5.4%
sub-neg5.4%
log1p-def5.4%
distribute-neg-frac5.4%
sub-neg5.4%
distribute-neg-in5.4%
remove-double-neg5.4%
+-commutative5.4%
sub-neg5.4%
Simplified5.4%
add-log-exp5.4%
exp-diff5.4%
exp-1-e5.4%
log1p-udef5.4%
add-exp-log5.4%
Applied egg-rr5.4%
Taylor expanded in y around -inf 99.8%
Final simplification99.9%
(FPCore (x y) :precision binary64 (if (<= (/ (- x y) (- 1.0 y)) 0.999999999999) (- 1.0 (log1p (* (/ 1.0 (- 1.0 y)) (- y x)))) (+ 1.0 (- (/ -1.0 y) (log (/ -1.0 y))))))
double code(double x, double y) {
double tmp;
if (((x - y) / (1.0 - y)) <= 0.999999999999) {
tmp = 1.0 - log1p(((1.0 / (1.0 - y)) * (y - x)));
} else {
tmp = 1.0 + ((-1.0 / y) - log((-1.0 / y)));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (((x - y) / (1.0 - y)) <= 0.999999999999) {
tmp = 1.0 - Math.log1p(((1.0 / (1.0 - y)) * (y - x)));
} else {
tmp = 1.0 + ((-1.0 / y) - Math.log((-1.0 / y)));
}
return tmp;
}
def code(x, y): tmp = 0 if ((x - y) / (1.0 - y)) <= 0.999999999999: tmp = 1.0 - math.log1p(((1.0 / (1.0 - y)) * (y - x))) else: tmp = 1.0 + ((-1.0 / y) - math.log((-1.0 / y))) return tmp
function code(x, y) tmp = 0.0 if (Float64(Float64(x - y) / Float64(1.0 - y)) <= 0.999999999999) tmp = Float64(1.0 - log1p(Float64(Float64(1.0 / Float64(1.0 - y)) * Float64(y - x)))); else tmp = Float64(1.0 + Float64(Float64(-1.0 / y) - log(Float64(-1.0 / y)))); end return tmp end
code[x_, y_] := If[LessEqual[N[(N[(x - y), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision], 0.999999999999], N[(1.0 - N[Log[1 + N[(N[(1.0 / N[(1.0 - y), $MachinePrecision]), $MachinePrecision] * N[(y - x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(N[(-1.0 / y), $MachinePrecision] - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x - y}{1 - y} \leq 0.999999999999:\\
\;\;\;\;1 - \mathsf{log1p}\left(\frac{1}{1 - y} \cdot \left(y - x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;1 + \left(\frac{-1}{y} - \log \left(\frac{-1}{y}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 x y) (-.f64 1 y)) < 0.999999999999000022Initial program 99.6%
sub-neg99.6%
log1p-def99.6%
distribute-neg-frac99.6%
sub-neg99.6%
distribute-neg-in99.6%
remove-double-neg99.6%
+-commutative99.6%
sub-neg99.6%
Simplified99.6%
clear-num99.6%
associate-/r/99.6%
Applied egg-rr99.6%
if 0.999999999999000022 < (/.f64 (-.f64 x y) (-.f64 1 y)) Initial program 4.8%
sub-neg4.8%
log1p-def4.8%
distribute-neg-frac4.8%
sub-neg4.8%
distribute-neg-in4.8%
remove-double-neg4.8%
+-commutative4.8%
sub-neg4.8%
Simplified4.8%
Taylor expanded in x around 0 4.8%
log1p-def4.8%
Simplified4.8%
Taylor expanded in y around inf 0.0%
+-commutative0.0%
log-rec0.0%
sub-neg0.0%
log-div67.4%
Simplified67.4%
Final simplification90.9%
(FPCore (x y) :precision binary64 (if (<= (/ (- x y) (- 1.0 y)) 0.999999999999) (- 1.0 (log1p (/ (- y x) (- 1.0 y)))) (+ 1.0 (- (/ -1.0 y) (log (/ -1.0 y))))))
double code(double x, double y) {
double tmp;
if (((x - y) / (1.0 - y)) <= 0.999999999999) {
tmp = 1.0 - log1p(((y - x) / (1.0 - y)));
} else {
tmp = 1.0 + ((-1.0 / y) - log((-1.0 / y)));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (((x - y) / (1.0 - y)) <= 0.999999999999) {
tmp = 1.0 - Math.log1p(((y - x) / (1.0 - y)));
} else {
tmp = 1.0 + ((-1.0 / y) - Math.log((-1.0 / y)));
}
return tmp;
}
def code(x, y): tmp = 0 if ((x - y) / (1.0 - y)) <= 0.999999999999: tmp = 1.0 - math.log1p(((y - x) / (1.0 - y))) else: tmp = 1.0 + ((-1.0 / y) - math.log((-1.0 / y))) return tmp
function code(x, y) tmp = 0.0 if (Float64(Float64(x - y) / Float64(1.0 - y)) <= 0.999999999999) tmp = Float64(1.0 - log1p(Float64(Float64(y - x) / Float64(1.0 - y)))); else tmp = Float64(1.0 + Float64(Float64(-1.0 / y) - log(Float64(-1.0 / y)))); end return tmp end
code[x_, y_] := If[LessEqual[N[(N[(x - y), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision], 0.999999999999], N[(1.0 - N[Log[1 + N[(N[(y - x), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(N[(-1.0 / y), $MachinePrecision] - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x - y}{1 - y} \leq 0.999999999999:\\
\;\;\;\;1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)\\
\mathbf{else}:\\
\;\;\;\;1 + \left(\frac{-1}{y} - \log \left(\frac{-1}{y}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 x y) (-.f64 1 y)) < 0.999999999999000022Initial program 99.6%
sub-neg99.6%
log1p-def99.6%
distribute-neg-frac99.6%
sub-neg99.6%
distribute-neg-in99.6%
remove-double-neg99.6%
+-commutative99.6%
sub-neg99.6%
Simplified99.6%
if 0.999999999999000022 < (/.f64 (-.f64 x y) (-.f64 1 y)) Initial program 4.8%
sub-neg4.8%
log1p-def4.8%
distribute-neg-frac4.8%
sub-neg4.8%
distribute-neg-in4.8%
remove-double-neg4.8%
+-commutative4.8%
sub-neg4.8%
Simplified4.8%
Taylor expanded in x around 0 4.8%
log1p-def4.8%
Simplified4.8%
Taylor expanded in y around inf 0.0%
+-commutative0.0%
log-rec0.0%
sub-neg0.0%
log-div67.4%
Simplified67.4%
Final simplification90.9%
(FPCore (x y)
:precision binary64
(if (<= y -3900000000000.0)
(- 1.0 (log (/ -1.0 y)))
(if (<= y 50000000000.0)
(- 1.0 (log1p (/ (- y x) (- 1.0 y))))
(- 1.0 (log (/ x (+ y -1.0)))))))
double code(double x, double y) {
double tmp;
if (y <= -3900000000000.0) {
tmp = 1.0 - log((-1.0 / y));
} else if (y <= 50000000000.0) {
tmp = 1.0 - log1p(((y - x) / (1.0 - y)));
} else {
tmp = 1.0 - log((x / (y + -1.0)));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (y <= -3900000000000.0) {
tmp = 1.0 - Math.log((-1.0 / y));
} else if (y <= 50000000000.0) {
tmp = 1.0 - Math.log1p(((y - x) / (1.0 - y)));
} else {
tmp = 1.0 - Math.log((x / (y + -1.0)));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -3900000000000.0: tmp = 1.0 - math.log((-1.0 / y)) elif y <= 50000000000.0: tmp = 1.0 - math.log1p(((y - x) / (1.0 - y))) else: tmp = 1.0 - math.log((x / (y + -1.0))) return tmp
function code(x, y) tmp = 0.0 if (y <= -3900000000000.0) tmp = Float64(1.0 - log(Float64(-1.0 / y))); elseif (y <= 50000000000.0) tmp = Float64(1.0 - log1p(Float64(Float64(y - x) / Float64(1.0 - y)))); else tmp = Float64(1.0 - log(Float64(x / Float64(y + -1.0)))); end return tmp end
code[x_, y_] := If[LessEqual[y, -3900000000000.0], N[(1.0 - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 50000000000.0], N[(1.0 - N[Log[1 + N[(N[(y - x), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Log[N[(x / N[(y + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3900000000000:\\
\;\;\;\;1 - \log \left(\frac{-1}{y}\right)\\
\mathbf{elif}\;y \leq 50000000000:\\
\;\;\;\;1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)\\
\mathbf{else}:\\
\;\;\;\;1 - \log \left(\frac{x}{y + -1}\right)\\
\end{array}
\end{array}
if y < -3.9e12Initial program 22.3%
sub-neg22.3%
log1p-def22.3%
distribute-neg-frac22.3%
sub-neg22.3%
distribute-neg-in22.3%
remove-double-neg22.3%
+-commutative22.3%
sub-neg22.3%
Simplified22.3%
Taylor expanded in x around 0 4.3%
log1p-def4.3%
Simplified4.3%
Taylor expanded in y around inf 0.0%
log-rec0.0%
sub-neg0.0%
log-div64.7%
Simplified64.7%
if -3.9e12 < y < 5e10Initial program 99.9%
sub-neg99.9%
log1p-def100.0%
distribute-neg-frac100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
if 5e10 < y Initial program 60.3%
sub-neg60.3%
log1p-def60.3%
distribute-neg-frac60.3%
sub-neg60.3%
distribute-neg-in60.3%
remove-double-neg60.3%
+-commutative60.3%
sub-neg60.3%
Simplified60.3%
Taylor expanded in x around inf 55.4%
neg-mul-155.4%
distribute-neg-frac55.4%
Simplified55.4%
frac-2neg55.4%
div-inv55.4%
remove-double-neg55.4%
Applied egg-rr55.4%
associate-*r/55.4%
*-rgt-identity55.4%
neg-sub055.4%
associate--r-55.4%
metadata-eval55.4%
Simplified55.4%
Taylor expanded in x around inf 97.9%
log-rec97.9%
unsub-neg97.9%
mul-1-neg97.9%
log-rec97.9%
remove-double-neg97.9%
sub-neg97.9%
metadata-eval97.9%
log-div99.7%
Simplified99.7%
Final simplification90.0%
(FPCore (x y)
:precision binary64
(if (<= y -55.0)
(- 1.0 (log (/ -1.0 y)))
(if (<= y 0.38)
(- 1.0 (+ y (log1p (- x))))
(- 1.0 (log (/ x (+ y -1.0)))))))
double code(double x, double y) {
double tmp;
if (y <= -55.0) {
tmp = 1.0 - log((-1.0 / y));
} else if (y <= 0.38) {
tmp = 1.0 - (y + log1p(-x));
} else {
tmp = 1.0 - log((x / (y + -1.0)));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (y <= -55.0) {
tmp = 1.0 - Math.log((-1.0 / y));
} else if (y <= 0.38) {
tmp = 1.0 - (y + Math.log1p(-x));
} else {
tmp = 1.0 - Math.log((x / (y + -1.0)));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -55.0: tmp = 1.0 - math.log((-1.0 / y)) elif y <= 0.38: tmp = 1.0 - (y + math.log1p(-x)) else: tmp = 1.0 - math.log((x / (y + -1.0))) return tmp
function code(x, y) tmp = 0.0 if (y <= -55.0) tmp = Float64(1.0 - log(Float64(-1.0 / y))); elseif (y <= 0.38) tmp = Float64(1.0 - Float64(y + log1p(Float64(-x)))); else tmp = Float64(1.0 - log(Float64(x / Float64(y + -1.0)))); end return tmp end
code[x_, y_] := If[LessEqual[y, -55.0], N[(1.0 - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 0.38], N[(1.0 - N[(y + N[Log[1 + (-x)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Log[N[(x / N[(y + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -55:\\
\;\;\;\;1 - \log \left(\frac{-1}{y}\right)\\
\mathbf{elif}\;y \leq 0.38:\\
\;\;\;\;1 - \left(y + \mathsf{log1p}\left(-x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;1 - \log \left(\frac{x}{y + -1}\right)\\
\end{array}
\end{array}
if y < -55Initial program 24.3%
sub-neg24.3%
log1p-def24.3%
distribute-neg-frac24.3%
sub-neg24.3%
distribute-neg-in24.3%
remove-double-neg24.3%
+-commutative24.3%
sub-neg24.3%
Simplified24.3%
Taylor expanded in x around 0 5.5%
log1p-def5.5%
Simplified5.5%
Taylor expanded in y around inf 0.0%
log-rec0.0%
sub-neg0.0%
log-div63.4%
Simplified63.4%
if -55 < y < 0.38Initial program 100.0%
sub-neg100.0%
log1p-def100.0%
distribute-neg-frac100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in y around 0 99.2%
div-sub99.2%
mul-1-neg99.2%
sub-neg99.2%
*-inverses99.2%
*-rgt-identity99.2%
log1p-def99.2%
mul-1-neg99.2%
Simplified99.2%
if 0.38 < y Initial program 61.8%
sub-neg61.8%
log1p-def61.8%
distribute-neg-frac61.8%
sub-neg61.8%
distribute-neg-in61.8%
remove-double-neg61.8%
+-commutative61.8%
sub-neg61.8%
Simplified61.8%
Taylor expanded in x around inf 54.5%
neg-mul-154.5%
distribute-neg-frac54.5%
Simplified54.5%
frac-2neg54.5%
div-inv54.5%
remove-double-neg54.5%
Applied egg-rr54.5%
associate-*r/54.5%
*-rgt-identity54.5%
neg-sub054.5%
associate--r-54.5%
metadata-eval54.5%
Simplified54.5%
Taylor expanded in x around inf 97.0%
log-rec97.0%
unsub-neg97.0%
mul-1-neg97.0%
log-rec97.0%
remove-double-neg97.0%
sub-neg97.0%
metadata-eval97.0%
log-div98.8%
Simplified98.8%
Final simplification88.8%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ x (+ y -1.0))))
(if (<= y -3800000000000.0)
(- 1.0 (log (/ -1.0 y)))
(if (<= y 1.0) (- 1.0 (log1p t_0)) (- 1.0 (log t_0))))))
double code(double x, double y) {
double t_0 = x / (y + -1.0);
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 - log((-1.0 / y));
} else if (y <= 1.0) {
tmp = 1.0 - log1p(t_0);
} else {
tmp = 1.0 - log(t_0);
}
return tmp;
}
public static double code(double x, double y) {
double t_0 = x / (y + -1.0);
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 - Math.log((-1.0 / y));
} else if (y <= 1.0) {
tmp = 1.0 - Math.log1p(t_0);
} else {
tmp = 1.0 - Math.log(t_0);
}
return tmp;
}
def code(x, y): t_0 = x / (y + -1.0) tmp = 0 if y <= -3800000000000.0: tmp = 1.0 - math.log((-1.0 / y)) elif y <= 1.0: tmp = 1.0 - math.log1p(t_0) else: tmp = 1.0 - math.log(t_0) return tmp
function code(x, y) t_0 = Float64(x / Float64(y + -1.0)) tmp = 0.0 if (y <= -3800000000000.0) tmp = Float64(1.0 - log(Float64(-1.0 / y))); elseif (y <= 1.0) tmp = Float64(1.0 - log1p(t_0)); else tmp = Float64(1.0 - log(t_0)); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(x / N[(y + -1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3800000000000.0], N[(1.0 - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.0], N[(1.0 - N[Log[1 + t$95$0], $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Log[t$95$0], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{y + -1}\\
\mathbf{if}\;y \leq -3800000000000:\\
\;\;\;\;1 - \log \left(\frac{-1}{y}\right)\\
\mathbf{elif}\;y \leq 1:\\
\;\;\;\;1 - \mathsf{log1p}\left(t_0\right)\\
\mathbf{else}:\\
\;\;\;\;1 - \log t_0\\
\end{array}
\end{array}
if y < -3.8e12Initial program 22.3%
sub-neg22.3%
log1p-def22.3%
distribute-neg-frac22.3%
sub-neg22.3%
distribute-neg-in22.3%
remove-double-neg22.3%
+-commutative22.3%
sub-neg22.3%
Simplified22.3%
Taylor expanded in x around 0 4.3%
log1p-def4.3%
Simplified4.3%
Taylor expanded in y around inf 0.0%
log-rec0.0%
sub-neg0.0%
log-div64.7%
Simplified64.7%
if -3.8e12 < y < 1Initial program 99.9%
sub-neg99.9%
log1p-def100.0%
distribute-neg-frac100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in x around inf 98.4%
neg-mul-198.4%
distribute-neg-frac98.4%
Simplified98.4%
frac-2neg98.4%
div-inv98.4%
remove-double-neg98.4%
Applied egg-rr98.4%
associate-*r/98.4%
*-rgt-identity98.4%
neg-sub098.4%
associate--r-98.4%
metadata-eval98.4%
Simplified98.4%
if 1 < y Initial program 61.8%
sub-neg61.8%
log1p-def61.8%
distribute-neg-frac61.8%
sub-neg61.8%
distribute-neg-in61.8%
remove-double-neg61.8%
+-commutative61.8%
sub-neg61.8%
Simplified61.8%
Taylor expanded in x around inf 54.5%
neg-mul-154.5%
distribute-neg-frac54.5%
Simplified54.5%
frac-2neg54.5%
div-inv54.5%
remove-double-neg54.5%
Applied egg-rr54.5%
associate-*r/54.5%
*-rgt-identity54.5%
neg-sub054.5%
associate--r-54.5%
metadata-eval54.5%
Simplified54.5%
Taylor expanded in x around inf 97.0%
log-rec97.0%
unsub-neg97.0%
mul-1-neg97.0%
log-rec97.0%
remove-double-neg97.0%
sub-neg97.0%
metadata-eval97.0%
log-div98.8%
Simplified98.8%
Final simplification88.9%
(FPCore (x y) :precision binary64 (if (<= y -29.0) (- 1.0 (log (/ -1.0 y))) (if (<= y 1.0) (- 1.0 (+ y (log1p (- x)))) (- 1.0 (log1p (/ x y))))))
double code(double x, double y) {
double tmp;
if (y <= -29.0) {
tmp = 1.0 - log((-1.0 / y));
} else if (y <= 1.0) {
tmp = 1.0 - (y + log1p(-x));
} else {
tmp = 1.0 - log1p((x / y));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (y <= -29.0) {
tmp = 1.0 - Math.log((-1.0 / y));
} else if (y <= 1.0) {
tmp = 1.0 - (y + Math.log1p(-x));
} else {
tmp = 1.0 - Math.log1p((x / y));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -29.0: tmp = 1.0 - math.log((-1.0 / y)) elif y <= 1.0: tmp = 1.0 - (y + math.log1p(-x)) else: tmp = 1.0 - math.log1p((x / y)) return tmp
function code(x, y) tmp = 0.0 if (y <= -29.0) tmp = Float64(1.0 - log(Float64(-1.0 / y))); elseif (y <= 1.0) tmp = Float64(1.0 - Float64(y + log1p(Float64(-x)))); else tmp = Float64(1.0 - log1p(Float64(x / y))); end return tmp end
code[x_, y_] := If[LessEqual[y, -29.0], N[(1.0 - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.0], N[(1.0 - N[(y + N[Log[1 + (-x)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Log[1 + N[(x / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -29:\\
\;\;\;\;1 - \log \left(\frac{-1}{y}\right)\\
\mathbf{elif}\;y \leq 1:\\
\;\;\;\;1 - \left(y + \mathsf{log1p}\left(-x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;1 - \mathsf{log1p}\left(\frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -29Initial program 24.3%
sub-neg24.3%
log1p-def24.3%
distribute-neg-frac24.3%
sub-neg24.3%
distribute-neg-in24.3%
remove-double-neg24.3%
+-commutative24.3%
sub-neg24.3%
Simplified24.3%
Taylor expanded in x around 0 5.5%
log1p-def5.5%
Simplified5.5%
Taylor expanded in y around inf 0.0%
log-rec0.0%
sub-neg0.0%
log-div63.4%
Simplified63.4%
if -29 < y < 1Initial program 100.0%
sub-neg100.0%
log1p-def100.0%
distribute-neg-frac100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in y around 0 99.2%
div-sub99.2%
mul-1-neg99.2%
sub-neg99.2%
*-inverses99.2%
*-rgt-identity99.2%
log1p-def99.2%
mul-1-neg99.2%
Simplified99.2%
if 1 < y Initial program 61.8%
sub-neg61.8%
log1p-def61.8%
distribute-neg-frac61.8%
sub-neg61.8%
distribute-neg-in61.8%
remove-double-neg61.8%
+-commutative61.8%
sub-neg61.8%
Simplified61.8%
Taylor expanded in x around inf 54.5%
neg-mul-154.5%
distribute-neg-frac54.5%
Simplified54.5%
Taylor expanded in y around inf 54.1%
Final simplification84.1%
(FPCore (x y) :precision binary64 (if (<= y -3800000000000.0) (- 1.0 (log (/ -1.0 y))) (if (<= y 1.0) (- 1.0 (log1p (- x))) (- 1.0 (log1p (/ x y))))))
double code(double x, double y) {
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 - log((-1.0 / y));
} else if (y <= 1.0) {
tmp = 1.0 - log1p(-x);
} else {
tmp = 1.0 - log1p((x / y));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 - Math.log((-1.0 / y));
} else if (y <= 1.0) {
tmp = 1.0 - Math.log1p(-x);
} else {
tmp = 1.0 - Math.log1p((x / y));
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -3800000000000.0: tmp = 1.0 - math.log((-1.0 / y)) elif y <= 1.0: tmp = 1.0 - math.log1p(-x) else: tmp = 1.0 - math.log1p((x / y)) return tmp
function code(x, y) tmp = 0.0 if (y <= -3800000000000.0) tmp = Float64(1.0 - log(Float64(-1.0 / y))); elseif (y <= 1.0) tmp = Float64(1.0 - log1p(Float64(-x))); else tmp = Float64(1.0 - log1p(Float64(x / y))); end return tmp end
code[x_, y_] := If[LessEqual[y, -3800000000000.0], N[(1.0 - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.0], N[(1.0 - N[Log[1 + (-x)], $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Log[1 + N[(x / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3800000000000:\\
\;\;\;\;1 - \log \left(\frac{-1}{y}\right)\\
\mathbf{elif}\;y \leq 1:\\
\;\;\;\;1 - \mathsf{log1p}\left(-x\right)\\
\mathbf{else}:\\
\;\;\;\;1 - \mathsf{log1p}\left(\frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -3.8e12Initial program 22.3%
sub-neg22.3%
log1p-def22.3%
distribute-neg-frac22.3%
sub-neg22.3%
distribute-neg-in22.3%
remove-double-neg22.3%
+-commutative22.3%
sub-neg22.3%
Simplified22.3%
Taylor expanded in x around 0 4.3%
log1p-def4.3%
Simplified4.3%
Taylor expanded in y around inf 0.0%
log-rec0.0%
sub-neg0.0%
log-div64.7%
Simplified64.7%
if -3.8e12 < y < 1Initial program 99.9%
sub-neg99.9%
log1p-def100.0%
distribute-neg-frac100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in y around 0 96.9%
log1p-def96.9%
mul-1-neg96.9%
Simplified96.9%
if 1 < y Initial program 61.8%
sub-neg61.8%
log1p-def61.8%
distribute-neg-frac61.8%
sub-neg61.8%
distribute-neg-in61.8%
remove-double-neg61.8%
+-commutative61.8%
sub-neg61.8%
Simplified61.8%
Taylor expanded in x around inf 54.5%
neg-mul-154.5%
distribute-neg-frac54.5%
Simplified54.5%
Taylor expanded in y around inf 54.1%
Final simplification83.3%
(FPCore (x y) :precision binary64 (if (<= y -3800000000000.0) (- 1.0 (log (/ -1.0 y))) (- 1.0 (log1p (- x)))))
double code(double x, double y) {
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 - log((-1.0 / y));
} else {
tmp = 1.0 - log1p(-x);
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 - Math.log((-1.0 / y));
} else {
tmp = 1.0 - Math.log1p(-x);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -3800000000000.0: tmp = 1.0 - math.log((-1.0 / y)) else: tmp = 1.0 - math.log1p(-x) return tmp
function code(x, y) tmp = 0.0 if (y <= -3800000000000.0) tmp = Float64(1.0 - log(Float64(-1.0 / y))); else tmp = Float64(1.0 - log1p(Float64(-x))); end return tmp end
code[x_, y_] := If[LessEqual[y, -3800000000000.0], N[(1.0 - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Log[1 + (-x)], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3800000000000:\\
\;\;\;\;1 - \log \left(\frac{-1}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;1 - \mathsf{log1p}\left(-x\right)\\
\end{array}
\end{array}
if y < -3.8e12Initial program 22.3%
sub-neg22.3%
log1p-def22.3%
distribute-neg-frac22.3%
sub-neg22.3%
distribute-neg-in22.3%
remove-double-neg22.3%
+-commutative22.3%
sub-neg22.3%
Simplified22.3%
Taylor expanded in x around 0 4.3%
log1p-def4.3%
Simplified4.3%
Taylor expanded in y around inf 0.0%
log-rec0.0%
sub-neg0.0%
log-div64.7%
Simplified64.7%
if -3.8e12 < y Initial program 94.3%
sub-neg94.3%
log1p-def94.4%
distribute-neg-frac94.4%
sub-neg94.4%
distribute-neg-in94.4%
remove-double-neg94.4%
+-commutative94.4%
sub-neg94.4%
Simplified94.4%
Taylor expanded in y around 0 82.7%
log1p-def82.7%
mul-1-neg82.7%
Simplified82.7%
Final simplification77.6%
(FPCore (x y) :precision binary64 (- 1.0 (log1p (- x))))
double code(double x, double y) {
return 1.0 - log1p(-x);
}
public static double code(double x, double y) {
return 1.0 - Math.log1p(-x);
}
def code(x, y): return 1.0 - math.log1p(-x)
function code(x, y) return Float64(1.0 - log1p(Float64(-x))) end
code[x_, y_] := N[(1.0 - N[Log[1 + (-x)], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \mathsf{log1p}\left(-x\right)
\end{array}
Initial program 74.1%
sub-neg74.1%
log1p-def74.1%
distribute-neg-frac74.1%
sub-neg74.1%
distribute-neg-in74.1%
remove-double-neg74.1%
+-commutative74.1%
sub-neg74.1%
Simplified74.1%
Taylor expanded in y around 0 62.9%
log1p-def63.0%
mul-1-neg63.0%
Simplified63.0%
Final simplification63.0%
(FPCore (x y) :precision binary64 (if (<= y -3800000000000.0) (+ 1.0 (/ -1.0 y)) (+ 1.0 (- x y))))
double code(double x, double y) {
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 + (-1.0 / y);
} else {
tmp = 1.0 + (x - y);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= (-3800000000000.0d0)) then
tmp = 1.0d0 + ((-1.0d0) / y)
else
tmp = 1.0d0 + (x - y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -3800000000000.0) {
tmp = 1.0 + (-1.0 / y);
} else {
tmp = 1.0 + (x - y);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -3800000000000.0: tmp = 1.0 + (-1.0 / y) else: tmp = 1.0 + (x - y) return tmp
function code(x, y) tmp = 0.0 if (y <= -3800000000000.0) tmp = Float64(1.0 + Float64(-1.0 / y)); else tmp = Float64(1.0 + Float64(x - y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -3800000000000.0) tmp = 1.0 + (-1.0 / y); else tmp = 1.0 + (x - y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -3800000000000.0], N[(1.0 + N[(-1.0 / y), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(x - y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3800000000000:\\
\;\;\;\;1 + \frac{-1}{y}\\
\mathbf{else}:\\
\;\;\;\;1 + \left(x - y\right)\\
\end{array}
\end{array}
if y < -3.8e12Initial program 22.3%
sub-neg22.3%
log1p-def22.3%
distribute-neg-frac22.3%
sub-neg22.3%
distribute-neg-in22.3%
remove-double-neg22.3%
+-commutative22.3%
sub-neg22.3%
Simplified22.3%
Taylor expanded in x around 0 4.3%
log1p-def4.3%
Simplified4.3%
Taylor expanded in y around inf 0.0%
+-commutative0.0%
log-rec0.0%
sub-neg0.0%
log-div64.8%
Simplified64.8%
Taylor expanded in y around 0 11.9%
if -3.8e12 < y Initial program 94.3%
sub-neg94.3%
log1p-def94.4%
distribute-neg-frac94.4%
sub-neg94.4%
distribute-neg-in94.4%
remove-double-neg94.4%
+-commutative94.4%
sub-neg94.4%
Simplified94.4%
Taylor expanded in x around 0 61.0%
+-commutative61.0%
mul-1-neg61.0%
unsub-neg61.0%
log1p-def61.0%
*-commutative61.0%
Simplified61.0%
Taylor expanded in y around 0 60.7%
mul-1-neg60.7%
sub-neg60.7%
Simplified60.7%
Final simplification47.0%
(FPCore (x y) :precision binary64 (+ 1.0 (- x y)))
double code(double x, double y) {
return 1.0 + (x - y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + (x - y)
end function
public static double code(double x, double y) {
return 1.0 + (x - y);
}
def code(x, y): return 1.0 + (x - y)
function code(x, y) return Float64(1.0 + Float64(x - y)) end
function tmp = code(x, y) tmp = 1.0 + (x - y); end
code[x_, y_] := N[(1.0 + N[(x - y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \left(x - y\right)
\end{array}
Initial program 74.1%
sub-neg74.1%
log1p-def74.1%
distribute-neg-frac74.1%
sub-neg74.1%
distribute-neg-in74.1%
remove-double-neg74.1%
+-commutative74.1%
sub-neg74.1%
Simplified74.1%
Taylor expanded in x around 0 44.6%
+-commutative44.6%
mul-1-neg44.6%
unsub-neg44.6%
log1p-def44.6%
*-commutative44.6%
Simplified44.6%
Taylor expanded in y around 0 45.0%
mul-1-neg45.0%
sub-neg45.0%
Simplified45.0%
Final simplification45.0%
(FPCore (x y) :precision binary64 (- 1.0 y))
double code(double x, double y) {
return 1.0 - y;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 - y
end function
public static double code(double x, double y) {
return 1.0 - y;
}
def code(x, y): return 1.0 - y
function code(x, y) return Float64(1.0 - y) end
function tmp = code(x, y) tmp = 1.0 - y; end
code[x_, y_] := N[(1.0 - y), $MachinePrecision]
\begin{array}{l}
\\
1 - y
\end{array}
Initial program 74.1%
sub-neg74.1%
log1p-def74.1%
distribute-neg-frac74.1%
sub-neg74.1%
distribute-neg-in74.1%
remove-double-neg74.1%
+-commutative74.1%
sub-neg74.1%
Simplified74.1%
Taylor expanded in x around 0 43.9%
log1p-def43.9%
Simplified43.9%
Taylor expanded in y around 0 43.8%
Final simplification43.8%
(FPCore (x y)
:precision binary64
(let* ((t_0 (- 1.0 (log (- (/ x (* y y)) (- (/ 1.0 y) (/ x y)))))))
(if (< y -81284752.61947241)
t_0
(if (< y 3.0094271212461764e+25)
(log (/ (exp 1.0) (- 1.0 (/ (- x y) (- 1.0 y)))))
t_0))))
double code(double x, double y) {
double t_0 = 1.0 - log(((x / (y * y)) - ((1.0 / y) - (x / y))));
double tmp;
if (y < -81284752.61947241) {
tmp = t_0;
} else if (y < 3.0094271212461764e+25) {
tmp = log((exp(1.0) / (1.0 - ((x - y) / (1.0 - y)))));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = 1.0d0 - log(((x / (y * y)) - ((1.0d0 / y) - (x / y))))
if (y < (-81284752.61947241d0)) then
tmp = t_0
else if (y < 3.0094271212461764d+25) then
tmp = log((exp(1.0d0) / (1.0d0 - ((x - y) / (1.0d0 - y)))))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = 1.0 - Math.log(((x / (y * y)) - ((1.0 / y) - (x / y))));
double tmp;
if (y < -81284752.61947241) {
tmp = t_0;
} else if (y < 3.0094271212461764e+25) {
tmp = Math.log((Math.exp(1.0) / (1.0 - ((x - y) / (1.0 - y)))));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = 1.0 - math.log(((x / (y * y)) - ((1.0 / y) - (x / y)))) tmp = 0 if y < -81284752.61947241: tmp = t_0 elif y < 3.0094271212461764e+25: tmp = math.log((math.exp(1.0) / (1.0 - ((x - y) / (1.0 - y))))) else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(1.0 - log(Float64(Float64(x / Float64(y * y)) - Float64(Float64(1.0 / y) - Float64(x / y))))) tmp = 0.0 if (y < -81284752.61947241) tmp = t_0; elseif (y < 3.0094271212461764e+25) tmp = log(Float64(exp(1.0) / Float64(1.0 - Float64(Float64(x - y) / Float64(1.0 - y))))); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = 1.0 - log(((x / (y * y)) - ((1.0 / y) - (x / y)))); tmp = 0.0; if (y < -81284752.61947241) tmp = t_0; elseif (y < 3.0094271212461764e+25) tmp = log((exp(1.0) / (1.0 - ((x - y) / (1.0 - y))))); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(1.0 - N[Log[N[(N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision] - N[(N[(1.0 / y), $MachinePrecision] - N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[Less[y, -81284752.61947241], t$95$0, If[Less[y, 3.0094271212461764e+25], N[Log[N[(N[Exp[1.0], $MachinePrecision] / N[(1.0 - N[(N[(x - y), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 - \log \left(\frac{x}{y \cdot y} - \left(\frac{1}{y} - \frac{x}{y}\right)\right)\\
\mathbf{if}\;y < -81284752.61947241:\\
\;\;\;\;t_0\\
\mathbf{elif}\;y < 3.0094271212461764 \cdot 10^{+25}:\\
\;\;\;\;\log \left(\frac{e^{1}}{1 - \frac{x - y}{1 - y}}\right)\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
herbie shell --seed 2023279
(FPCore (x y)
:name "Numeric.SpecFunctions:invIncompleteGamma from math-functions-0.1.5.2, B"
:precision binary64
:herbie-target
(if (< y -81284752.61947241) (- 1.0 (log (- (/ x (* y y)) (- (/ 1.0 y) (/ x y))))) (if (< y 3.0094271212461764e+25) (log (/ (exp 1.0) (- 1.0 (/ (- x y) (- 1.0 y))))) (- 1.0 (log (- (/ x (* y y)) (- (/ 1.0 y) (/ x y)))))))
(- 1.0 (log (- 1.0 (/ (- x y) (- 1.0 y))))))