
(FPCore (x y) :precision binary64 (/ (exp (* x (log (/ x (+ x y))))) x))
double code(double x, double y) {
return exp((x * log((x / (x + y))))) / x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp((x * log((x / (x + y))))) / x
end function
public static double code(double x, double y) {
return Math.exp((x * Math.log((x / (x + y))))) / x;
}
def code(x, y): return math.exp((x * math.log((x / (x + y))))) / x
function code(x, y) return Float64(exp(Float64(x * log(Float64(x / Float64(x + y))))) / x) end
function tmp = code(x, y) tmp = exp((x * log((x / (x + y))))) / x; end
code[x_, y_] := N[(N[Exp[N[(x * N[Log[N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / x), $MachinePrecision]
\begin{array}{l}
\\
\frac{e^{x \cdot \log \left(\frac{x}{x + y}\right)}}{x}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (/ (exp (* x (log (/ x (+ x y))))) x))
double code(double x, double y) {
return exp((x * log((x / (x + y))))) / x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = exp((x * log((x / (x + y))))) / x
end function
public static double code(double x, double y) {
return Math.exp((x * Math.log((x / (x + y))))) / x;
}
def code(x, y): return math.exp((x * math.log((x / (x + y))))) / x
function code(x, y) return Float64(exp(Float64(x * log(Float64(x / Float64(x + y))))) / x) end
function tmp = code(x, y) tmp = exp((x * log((x / (x + y))))) / x; end
code[x_, y_] := N[(N[Exp[N[(x * N[Log[N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / x), $MachinePrecision]
\begin{array}{l}
\\
\frac{e^{x \cdot \log \left(\frac{x}{x + y}\right)}}{x}
\end{array}
(FPCore (x y) :precision binary64 (let* ((t_0 (/ (exp (- y)) x))) (if (<= x -2800000000000.0) t_0 (if (<= x 7.1e-9) (/ 1.0 x) t_0))))
double code(double x, double y) {
double t_0 = exp(-y) / x;
double tmp;
if (x <= -2800000000000.0) {
tmp = t_0;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} 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 = exp(-y) / x
if (x <= (-2800000000000.0d0)) then
tmp = t_0
else if (x <= 7.1d-9) then
tmp = 1.0d0 / x
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.exp(-y) / x;
double tmp;
if (x <= -2800000000000.0) {
tmp = t_0;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = math.exp(-y) / x tmp = 0 if x <= -2800000000000.0: tmp = t_0 elif x <= 7.1e-9: tmp = 1.0 / x else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(exp(Float64(-y)) / x) tmp = 0.0 if (x <= -2800000000000.0) tmp = t_0; elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = exp(-y) / x; tmp = 0.0; if (x <= -2800000000000.0) tmp = t_0; elseif (x <= 7.1e-9) tmp = 1.0 / x; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[Exp[(-y)], $MachinePrecision] / x), $MachinePrecision]}, If[LessEqual[x, -2800000000000.0], t$95$0, If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{e^{-y}}{x}\\
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -2.8e12 or 7.09999999999999988e-9 < x Initial program 75.8%
Taylor expanded in x around inf
mul-1-negN/A
lower-neg.f64100.0
Applied rewrites100.0%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
(FPCore (x y)
:precision binary64
(if (<= x -5.6e+26)
(/
(*
(fma (* y (* y y)) (fma y (fma y -3.0 -3.0) -2.0) 1.0)
(fma (fma y y y) (+ (fma y y y) -1.0) 1.0))
x)
(if (<= x 7.1e-9)
(/ 1.0 x)
(/ 1.0 (fma y (fma (- y) (fma x (+ 0.5 (/ 0.5 x)) (- x)) x) x)))))
double code(double x, double y) {
double tmp;
if (x <= -5.6e+26) {
tmp = (fma((y * (y * y)), fma(y, fma(y, -3.0, -3.0), -2.0), 1.0) * fma(fma(y, y, y), (fma(y, y, y) + -1.0), 1.0)) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / fma(y, fma(-y, fma(x, (0.5 + (0.5 / x)), -x), x), x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -5.6e+26) tmp = Float64(Float64(fma(Float64(y * Float64(y * y)), fma(y, fma(y, -3.0, -3.0), -2.0), 1.0) * fma(fma(y, y, y), Float64(fma(y, y, y) + -1.0), 1.0)) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / fma(y, fma(Float64(-y), fma(x, Float64(0.5 + Float64(0.5 / x)), Float64(-x)), x), x)); end return tmp end
code[x_, y_] := If[LessEqual[x, -5.6e+26], N[(N[(N[(N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(y * N[(y * -3.0 + -3.0), $MachinePrecision] + -2.0), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(y * y + y), $MachinePrecision] * N[(N[(y * y + y), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(y * N[((-y) * N[(x * N[(0.5 + N[(0.5 / x), $MachinePrecision]), $MachinePrecision] + (-x)), $MachinePrecision] + x), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5.6 \cdot 10^{+26}:\\
\;\;\;\;\frac{\mathsf{fma}\left(y \cdot \left(y \cdot y\right), \mathsf{fma}\left(y, \mathsf{fma}\left(y, -3, -3\right), -2\right), 1\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(y, y, y\right), \mathsf{fma}\left(y, y, y\right) + -1, 1\right)}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(y, \mathsf{fma}\left(-y, \mathsf{fma}\left(x, 0.5 + \frac{0.5}{x}, -x\right), x\right), x\right)}\\
\end{array}
\end{array}
if x < -5.59999999999999999e26Initial program 76.6%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f6458.4
Applied rewrites58.4%
Applied rewrites64.4%
Applied rewrites60.7%
Taylor expanded in y around 0
Applied rewrites86.5%
if -5.59999999999999999e26 < x < 7.09999999999999988e-9Initial program 85.2%
Taylor expanded in x around 0
Applied rewrites97.4%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in x around inf
Applied rewrites68.2%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6475.2
Applied rewrites75.2%
Final simplification87.4%
(FPCore (x y)
:precision binary64
(if (<= x -2800000000000.0)
(/
(* (fma (fma y y y) (+ (fma y y y) -1.0) 1.0) (fma y (* (* y y) -2.0) 1.0))
x)
(if (<= x 7.1e-9)
(/ 1.0 x)
(/ 1.0 (fma y (fma (- y) (fma x (+ 0.5 (/ 0.5 x)) (- x)) x) x)))))
double code(double x, double y) {
double tmp;
if (x <= -2800000000000.0) {
tmp = (fma(fma(y, y, y), (fma(y, y, y) + -1.0), 1.0) * fma(y, ((y * y) * -2.0), 1.0)) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / fma(y, fma(-y, fma(x, (0.5 + (0.5 / x)), -x), x), x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2800000000000.0) tmp = Float64(Float64(fma(fma(y, y, y), Float64(fma(y, y, y) + -1.0), 1.0) * fma(y, Float64(Float64(y * y) * -2.0), 1.0)) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / fma(y, fma(Float64(-y), fma(x, Float64(0.5 + Float64(0.5 / x)), Float64(-x)), x), x)); end return tmp end
code[x_, y_] := If[LessEqual[x, -2800000000000.0], N[(N[(N[(N[(y * y + y), $MachinePrecision] * N[(N[(y * y + y), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] * N[(y * N[(N[(y * y), $MachinePrecision] * -2.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(y * N[((-y) * N[(x * N[(0.5 + N[(0.5 / x), $MachinePrecision]), $MachinePrecision] + (-x)), $MachinePrecision] + x), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;\frac{\mathsf{fma}\left(\mathsf{fma}\left(y, y, y\right), \mathsf{fma}\left(y, y, y\right) + -1, 1\right) \cdot \mathsf{fma}\left(y, \left(y \cdot y\right) \cdot -2, 1\right)}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(y, \mathsf{fma}\left(-y, \mathsf{fma}\left(x, 0.5 + \frac{0.5}{x}, -x\right), x\right), x\right)}\\
\end{array}
\end{array}
if x < -2.8e12Initial program 76.3%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f6459.0
Applied rewrites59.0%
Applied rewrites64.7%
Applied rewrites61.2%
Taylor expanded in y around 0
Applied rewrites82.7%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in x around inf
Applied rewrites68.2%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6475.2
Applied rewrites75.2%
Final simplification86.7%
(FPCore (x y)
:precision binary64
(if (<= x -2800000000000.0)
(/ (/ (+ x (* y (fma x (fma y 0.5 -1.0) (* y 0.5)))) x) x)
(if (<= x 7.1e-9)
(/ 1.0 x)
(/ 1.0 (fma y (fma (- y) (fma x (+ 0.5 (/ 0.5 x)) (- x)) x) x)))))
double code(double x, double y) {
double tmp;
if (x <= -2800000000000.0) {
tmp = ((x + (y * fma(x, fma(y, 0.5, -1.0), (y * 0.5)))) / x) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / fma(y, fma(-y, fma(x, (0.5 + (0.5 / x)), -x), x), x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2800000000000.0) tmp = Float64(Float64(Float64(x + Float64(y * fma(x, fma(y, 0.5, -1.0), Float64(y * 0.5)))) / x) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / fma(y, fma(Float64(-y), fma(x, Float64(0.5 + Float64(0.5 / x)), Float64(-x)), x), x)); end return tmp end
code[x_, y_] := If[LessEqual[x, -2800000000000.0], N[(N[(N[(x + N[(y * N[(x * N[(y * 0.5 + -1.0), $MachinePrecision] + N[(y * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(y * N[((-y) * N[(x * N[(0.5 + N[(0.5 / x), $MachinePrecision]), $MachinePrecision] + (-x)), $MachinePrecision] + x), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;\frac{\frac{x + y \cdot \mathsf{fma}\left(x, \mathsf{fma}\left(y, 0.5, -1\right), y \cdot 0.5\right)}{x}}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(y, \mathsf{fma}\left(-y, \mathsf{fma}\left(x, 0.5 + \frac{0.5}{x}, -x\right), x\right), x\right)}\\
\end{array}
\end{array}
if x < -2.8e12Initial program 76.3%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6471.6
Applied rewrites71.6%
Taylor expanded in x around 0
Applied rewrites79.5%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in x around inf
Applied rewrites68.2%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6475.2
Applied rewrites75.2%
(FPCore (x y)
:precision binary64
(if (<= x -2800000000000.0)
(/ (* (fma (fma y y y) (+ (fma y y y) -1.0) 1.0) 1.0) x)
(if (<= x 7.1e-9)
(/ 1.0 x)
(/ 1.0 (fma y (fma (- y) (fma x (+ 0.5 (/ 0.5 x)) (- x)) x) x)))))
double code(double x, double y) {
double tmp;
if (x <= -2800000000000.0) {
tmp = (fma(fma(y, y, y), (fma(y, y, y) + -1.0), 1.0) * 1.0) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / fma(y, fma(-y, fma(x, (0.5 + (0.5 / x)), -x), x), x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2800000000000.0) tmp = Float64(Float64(fma(fma(y, y, y), Float64(fma(y, y, y) + -1.0), 1.0) * 1.0) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / fma(y, fma(Float64(-y), fma(x, Float64(0.5 + Float64(0.5 / x)), Float64(-x)), x), x)); end return tmp end
code[x_, y_] := If[LessEqual[x, -2800000000000.0], N[(N[(N[(N[(y * y + y), $MachinePrecision] * N[(N[(y * y + y), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] * 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(y * N[((-y) * N[(x * N[(0.5 + N[(0.5 / x), $MachinePrecision]), $MachinePrecision] + (-x)), $MachinePrecision] + x), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;\frac{\mathsf{fma}\left(\mathsf{fma}\left(y, y, y\right), \mathsf{fma}\left(y, y, y\right) + -1, 1\right) \cdot 1}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(y, \mathsf{fma}\left(-y, \mathsf{fma}\left(x, 0.5 + \frac{0.5}{x}, -x\right), x\right), x\right)}\\
\end{array}
\end{array}
if x < -2.8e12Initial program 76.3%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f6459.0
Applied rewrites59.0%
Applied rewrites64.7%
Applied rewrites61.2%
Taylor expanded in y around 0
Applied rewrites78.0%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in x around inf
Applied rewrites68.2%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6475.2
Applied rewrites75.2%
Final simplification85.6%
(FPCore (x y) :precision binary64 (if (<= x -2800000000000.0) (/ (* (fma (fma y y y) (+ (fma y y y) -1.0) 1.0) 1.0) x) (if (<= x 7.1e-9) (/ 1.0 x) (/ (/ 1.0 (+ 1.0 (fma y y y))) x))))
double code(double x, double y) {
double tmp;
if (x <= -2800000000000.0) {
tmp = (fma(fma(y, y, y), (fma(y, y, y) + -1.0), 1.0) * 1.0) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = (1.0 / (1.0 + fma(y, y, y))) / x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2800000000000.0) tmp = Float64(Float64(fma(fma(y, y, y), Float64(fma(y, y, y) + -1.0), 1.0) * 1.0) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(Float64(1.0 / Float64(1.0 + fma(y, y, y))) / x); end return tmp end
code[x_, y_] := If[LessEqual[x, -2800000000000.0], N[(N[(N[(N[(y * y + y), $MachinePrecision] * N[(N[(y * y + y), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] * 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(N[(1.0 / N[(1.0 + N[(y * y + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;\frac{\mathsf{fma}\left(\mathsf{fma}\left(y, y, y\right), \mathsf{fma}\left(y, y, y\right) + -1, 1\right) \cdot 1}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{1 + \mathsf{fma}\left(y, y, y\right)}}{x}\\
\end{array}
\end{array}
if x < -2.8e12Initial program 76.3%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f6459.0
Applied rewrites59.0%
Applied rewrites64.7%
Applied rewrites61.2%
Taylor expanded in y around 0
Applied rewrites78.0%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f6462.6
Applied rewrites62.6%
Applied rewrites65.5%
Taylor expanded in y around 0
Applied rewrites75.1%
Final simplification85.5%
(FPCore (x y) :precision binary64 (if (<= x -2800000000000.0) (/ (/ (- x (* x y)) x) x) (if (<= x 7.1e-9) (/ 1.0 x) (/ (/ 1.0 (+ 1.0 (fma y y y))) x))))
double code(double x, double y) {
double tmp;
if (x <= -2800000000000.0) {
tmp = ((x - (x * y)) / x) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = (1.0 / (1.0 + fma(y, y, y))) / x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2800000000000.0) tmp = Float64(Float64(Float64(x - Float64(x * y)) / x) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(Float64(1.0 / Float64(1.0 + fma(y, y, y))) / x); end return tmp end
code[x_, y_] := If[LessEqual[x, -2800000000000.0], N[(N[(N[(x - N[(x * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(N[(1.0 / N[(1.0 + N[(y * y + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;\frac{\frac{x - x \cdot y}{x}}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{1 + \mathsf{fma}\left(y, y, y\right)}}{x}\\
\end{array}
\end{array}
if x < -2.8e12Initial program 76.3%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6471.6
Applied rewrites71.6%
Taylor expanded in x around 0
Applied rewrites79.5%
Taylor expanded in y around 0
Applied rewrites73.2%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f6462.6
Applied rewrites62.6%
Applied rewrites65.5%
Taylor expanded in y around 0
Applied rewrites75.1%
(FPCore (x y) :precision binary64 (if (<= x -2800000000000.0) (/ (/ (- x (* x y)) x) x) (if (<= x 7.1e-9) (/ 1.0 x) (/ 1.0 (fma x y x)))))
double code(double x, double y) {
double tmp;
if (x <= -2800000000000.0) {
tmp = ((x - (x * y)) / x) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / fma(x, y, x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2800000000000.0) tmp = Float64(Float64(Float64(x - Float64(x * y)) / x) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / fma(x, y, x)); end return tmp end
code[x_, y_] := If[LessEqual[x, -2800000000000.0], N[(N[(N[(x - N[(x * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(x * y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;\frac{\frac{x - x \cdot y}{x}}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(x, y, x\right)}\\
\end{array}
\end{array}
if x < -2.8e12Initial program 76.3%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6471.6
Applied rewrites71.6%
Taylor expanded in x around 0
Applied rewrites79.5%
Taylor expanded in y around 0
Applied rewrites73.2%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in x around inf
Applied rewrites68.2%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f6471.7
Applied rewrites71.7%
(FPCore (x y) :precision binary64 (if (<= x -2800000000000.0) (/ (fma y (fma y 0.5 -1.0) 1.0) x) (if (<= x 7.1e-9) (/ 1.0 x) (/ 1.0 (fma x y x)))))
double code(double x, double y) {
double tmp;
if (x <= -2800000000000.0) {
tmp = fma(y, fma(y, 0.5, -1.0), 1.0) / x;
} else if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / fma(x, y, x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -2800000000000.0) tmp = Float64(fma(y, fma(y, 0.5, -1.0), 1.0) / x); elseif (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / fma(x, y, x)); end return tmp end
code[x_, y_] := If[LessEqual[x, -2800000000000.0], N[(N[(y * N[(y * 0.5 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(x * y + x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2800000000000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5, -1\right), 1\right)}{x}\\
\mathbf{elif}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(x, y, x\right)}\\
\end{array}
\end{array}
if x < -2.8e12Initial program 76.3%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6471.6
Applied rewrites71.6%
Taylor expanded in x around inf
Applied rewrites71.6%
if -2.8e12 < x < 7.09999999999999988e-9Initial program 85.6%
Taylor expanded in x around 0
Applied rewrites98.1%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in x around inf
Applied rewrites68.2%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f6471.7
Applied rewrites71.7%
(FPCore (x y) :precision binary64 (if (<= x 7.1e-9) (/ 1.0 x) (/ 1.0 (fma x y x))))
double code(double x, double y) {
double tmp;
if (x <= 7.1e-9) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / fma(x, y, x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= 7.1e-9) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / fma(x, y, x)); end return tmp end
code[x_, y_] := If[LessEqual[x, 7.1e-9], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(x * y + x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 7.1 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(x, y, x\right)}\\
\end{array}
\end{array}
if x < 7.09999999999999988e-9Initial program 82.3%
Taylor expanded in x around 0
Applied rewrites83.9%
if 7.09999999999999988e-9 < x Initial program 75.5%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in x around inf
Applied rewrites68.2%
lift-/.f64N/A
clear-numN/A
lower-/.f64N/A
lower-/.f6468.2
Applied rewrites68.2%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f6471.7
Applied rewrites71.7%
(FPCore (x y) :precision binary64 (/ 1.0 x))
double code(double x, double y) {
return 1.0 / x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 / x
end function
public static double code(double x, double y) {
return 1.0 / x;
}
def code(x, y): return 1.0 / x
function code(x, y) return Float64(1.0 / x) end
function tmp = code(x, y) tmp = 1.0 / x; end
code[x_, y_] := N[(1.0 / x), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{x}
\end{array}
Initial program 80.0%
Taylor expanded in x around 0
Applied rewrites76.6%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ (exp (/ -1.0 y)) x)) (t_1 (/ (pow (/ x (+ y x)) x) x)))
(if (< y -3.7311844206647956e+94)
t_0
(if (< y 2.817959242728288e+37)
t_1
(if (< y 2.347387415166998e+178) (log (exp t_1)) t_0)))))
double code(double x, double y) {
double t_0 = exp((-1.0 / y)) / x;
double t_1 = pow((x / (y + x)), x) / x;
double tmp;
if (y < -3.7311844206647956e+94) {
tmp = t_0;
} else if (y < 2.817959242728288e+37) {
tmp = t_1;
} else if (y < 2.347387415166998e+178) {
tmp = log(exp(t_1));
} 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) :: t_1
real(8) :: tmp
t_0 = exp(((-1.0d0) / y)) / x
t_1 = ((x / (y + x)) ** x) / x
if (y < (-3.7311844206647956d+94)) then
tmp = t_0
else if (y < 2.817959242728288d+37) then
tmp = t_1
else if (y < 2.347387415166998d+178) then
tmp = log(exp(t_1))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.exp((-1.0 / y)) / x;
double t_1 = Math.pow((x / (y + x)), x) / x;
double tmp;
if (y < -3.7311844206647956e+94) {
tmp = t_0;
} else if (y < 2.817959242728288e+37) {
tmp = t_1;
} else if (y < 2.347387415166998e+178) {
tmp = Math.log(Math.exp(t_1));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = math.exp((-1.0 / y)) / x t_1 = math.pow((x / (y + x)), x) / x tmp = 0 if y < -3.7311844206647956e+94: tmp = t_0 elif y < 2.817959242728288e+37: tmp = t_1 elif y < 2.347387415166998e+178: tmp = math.log(math.exp(t_1)) else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(exp(Float64(-1.0 / y)) / x) t_1 = Float64((Float64(x / Float64(y + x)) ^ x) / x) tmp = 0.0 if (y < -3.7311844206647956e+94) tmp = t_0; elseif (y < 2.817959242728288e+37) tmp = t_1; elseif (y < 2.347387415166998e+178) tmp = log(exp(t_1)); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = exp((-1.0 / y)) / x; t_1 = ((x / (y + x)) ^ x) / x; tmp = 0.0; if (y < -3.7311844206647956e+94) tmp = t_0; elseif (y < 2.817959242728288e+37) tmp = t_1; elseif (y < 2.347387415166998e+178) tmp = log(exp(t_1)); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[Exp[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision] / x), $MachinePrecision]}, Block[{t$95$1 = N[(N[Power[N[(x / N[(y + x), $MachinePrecision]), $MachinePrecision], x], $MachinePrecision] / x), $MachinePrecision]}, If[Less[y, -3.7311844206647956e+94], t$95$0, If[Less[y, 2.817959242728288e+37], t$95$1, If[Less[y, 2.347387415166998e+178], N[Log[N[Exp[t$95$1], $MachinePrecision]], $MachinePrecision], t$95$0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{e^{\frac{-1}{y}}}{x}\\
t_1 := \frac{{\left(\frac{x}{y + x}\right)}^{x}}{x}\\
\mathbf{if}\;y < -3.7311844206647956 \cdot 10^{+94}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y < 2.817959242728288 \cdot 10^{+37}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y < 2.347387415166998 \cdot 10^{+178}:\\
\;\;\;\;\log \left(e^{t\_1}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
herbie shell --seed 2024222
(FPCore (x y)
:name "Numeric.SpecFunctions:invIncompleteBetaWorker from math-functions-0.1.5.2, F"
:precision binary64
:alt
(! :herbie-platform default (if (< y -37311844206647956000000000000000000000000000000000000000000000000000000000000000000000000000000) (/ (exp (/ -1 y)) x) (if (< y 28179592427282880000000000000000000000) (/ (pow (/ x (+ y x)) x) x) (if (< y 23473874151669980000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (log (exp (/ (pow (/ x (+ y x)) x) x))) (/ (exp (/ -1 y)) x)))))
(/ (exp (* x (log (/ x (+ x y))))) x))