
(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 8 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 -22000.0) t_0 (if (<= x 7e-38) (/ 1.0 x) t_0))))
double code(double x, double y) {
double t_0 = exp(-y) / x;
double tmp;
if (x <= -22000.0) {
tmp = t_0;
} else if (x <= 7e-38) {
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 <= (-22000.0d0)) then
tmp = t_0
else if (x <= 7d-38) 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 <= -22000.0) {
tmp = t_0;
} else if (x <= 7e-38) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = math.exp(-y) / x tmp = 0 if x <= -22000.0: tmp = t_0 elif x <= 7e-38: 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 <= -22000.0) tmp = t_0; elseif (x <= 7e-38) 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 <= -22000.0) tmp = t_0; elseif (x <= 7e-38) 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, -22000.0], t$95$0, If[LessEqual[x, 7e-38], N[(1.0 / x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{e^{-y}}{x}\\
\mathbf{if}\;x \leq -22000:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-38}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -22000 or 7.0000000000000003e-38 < x Initial program 71.7%
Taylor expanded in x around inf
mul-1-negN/A
lower-neg.f6499.4
Applied rewrites99.4%
if -22000 < x < 7.0000000000000003e-38Initial program 86.8%
Taylor expanded in x around 0
Applied rewrites100.0%
(FPCore (x y)
:precision binary64
(if (<= x -1.2e+154)
(/ (/ (- x (* x y)) x) x)
(if (<= x -5.8e+36)
(/ (+ x (* y (fma x (fma y 0.5 -1.0) (* y 0.5)))) (* x x))
(if (<= x 1850.0)
(/ 1.0 x)
(if (<= x 1.65e+180)
(/
(/
(fma (fma y 0.5 -1.0) (* y (* y (fma y 0.5 -1.0))) -1.0)
(fma y (fma y 0.5 -1.0) -1.0))
x)
(* x (/ 1.0 (* x (- x)))))))))
double code(double x, double y) {
double tmp;
if (x <= -1.2e+154) {
tmp = ((x - (x * y)) / x) / x;
} else if (x <= -5.8e+36) {
tmp = (x + (y * fma(x, fma(y, 0.5, -1.0), (y * 0.5)))) / (x * x);
} else if (x <= 1850.0) {
tmp = 1.0 / x;
} else if (x <= 1.65e+180) {
tmp = (fma(fma(y, 0.5, -1.0), (y * (y * fma(y, 0.5, -1.0))), -1.0) / fma(y, fma(y, 0.5, -1.0), -1.0)) / x;
} else {
tmp = x * (1.0 / (x * -x));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -1.2e+154) tmp = Float64(Float64(Float64(x - Float64(x * y)) / x) / x); elseif (x <= -5.8e+36) tmp = Float64(Float64(x + Float64(y * fma(x, fma(y, 0.5, -1.0), Float64(y * 0.5)))) / Float64(x * x)); elseif (x <= 1850.0) tmp = Float64(1.0 / x); elseif (x <= 1.65e+180) tmp = Float64(Float64(fma(fma(y, 0.5, -1.0), Float64(y * Float64(y * fma(y, 0.5, -1.0))), -1.0) / fma(y, fma(y, 0.5, -1.0), -1.0)) / x); else tmp = Float64(x * Float64(1.0 / Float64(x * Float64(-x)))); end return tmp end
code[x_, y_] := If[LessEqual[x, -1.2e+154], N[(N[(N[(x - N[(x * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, -5.8e+36], N[(N[(x + N[(y * N[(x * N[(y * 0.5 + -1.0), $MachinePrecision] + N[(y * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1850.0], N[(1.0 / x), $MachinePrecision], If[LessEqual[x, 1.65e+180], N[(N[(N[(N[(y * 0.5 + -1.0), $MachinePrecision] * N[(y * N[(y * N[(y * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] / N[(y * N[(y * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(x * N[(1.0 / N[(x * (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.2 \cdot 10^{+154}:\\
\;\;\;\;\frac{\frac{x - x \cdot y}{x}}{x}\\
\mathbf{elif}\;x \leq -5.8 \cdot 10^{+36}:\\
\;\;\;\;\frac{x + y \cdot \mathsf{fma}\left(x, \mathsf{fma}\left(y, 0.5, -1\right), y \cdot 0.5\right)}{x \cdot x}\\
\mathbf{elif}\;x \leq 1850:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{elif}\;x \leq 1.65 \cdot 10^{+180}:\\
\;\;\;\;\frac{\frac{\mathsf{fma}\left(\mathsf{fma}\left(y, 0.5, -1\right), y \cdot \left(y \cdot \mathsf{fma}\left(y, 0.5, -1\right)\right), -1\right)}{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5, -1\right), -1\right)}}{x}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{x \cdot \left(-x\right)}\\
\end{array}
\end{array}
if x < -1.20000000000000007e154Initial program 53.9%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
Applied rewrites62.5%
if -1.20000000000000007e154 < x < -5.8e36Initial program 85.3%
Taylor expanded in y around 0
lower-fma.f64N/A
sub-negN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6468.5
Applied rewrites68.5%
Taylor expanded in x around inf
Applied rewrites78.0%
Taylor expanded in x around 0
Applied rewrites87.8%
if -5.8e36 < x < 1850Initial program 88.2%
Taylor expanded in x around 0
Applied rewrites98.5%
if 1850 < x < 1.64999999999999995e180Initial program 82.7%
Taylor expanded in y around 0
lower-fma.f64N/A
sub-negN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6460.2
Applied rewrites60.2%
Taylor expanded in x around inf
Applied rewrites60.2%
Applied rewrites71.1%
if 1.64999999999999995e180 < x Initial program 52.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6429.5
Applied rewrites29.5%
Applied rewrites13.3%
Applied rewrites55.9%
Taylor expanded in y around 0
Applied rewrites55.9%
Final simplification84.1%
(FPCore (x y)
:precision binary64
(if (<= x -22000.0)
(/
(fma
y
(fma
y
(+
0.5
(-
(/ 0.5 x)
(*
y
(+
(/ 0.5 x)
(+ 0.16666666666666666 (/ 0.3333333333333333 (* x x)))))))
-1.0)
1.0)
x)
(if (<= x 1850.0)
(/ 1.0 x)
(if (<= x 1.65e+180)
(/
(/
(fma (fma y 0.5 -1.0) (* y (* y (fma y 0.5 -1.0))) -1.0)
(fma y (fma y 0.5 -1.0) -1.0))
x)
(* x (/ 1.0 (* x (- x))))))))
double code(double x, double y) {
double tmp;
if (x <= -22000.0) {
tmp = fma(y, fma(y, (0.5 + ((0.5 / x) - (y * ((0.5 / x) + (0.16666666666666666 + (0.3333333333333333 / (x * x))))))), -1.0), 1.0) / x;
} else if (x <= 1850.0) {
tmp = 1.0 / x;
} else if (x <= 1.65e+180) {
tmp = (fma(fma(y, 0.5, -1.0), (y * (y * fma(y, 0.5, -1.0))), -1.0) / fma(y, fma(y, 0.5, -1.0), -1.0)) / x;
} else {
tmp = x * (1.0 / (x * -x));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -22000.0) tmp = Float64(fma(y, fma(y, Float64(0.5 + Float64(Float64(0.5 / x) - Float64(y * Float64(Float64(0.5 / x) + Float64(0.16666666666666666 + Float64(0.3333333333333333 / Float64(x * x))))))), -1.0), 1.0) / x); elseif (x <= 1850.0) tmp = Float64(1.0 / x); elseif (x <= 1.65e+180) tmp = Float64(Float64(fma(fma(y, 0.5, -1.0), Float64(y * Float64(y * fma(y, 0.5, -1.0))), -1.0) / fma(y, fma(y, 0.5, -1.0), -1.0)) / x); else tmp = Float64(x * Float64(1.0 / Float64(x * Float64(-x)))); end return tmp end
code[x_, y_] := If[LessEqual[x, -22000.0], N[(N[(y * N[(y * N[(0.5 + N[(N[(0.5 / x), $MachinePrecision] - N[(y * N[(N[(0.5 / x), $MachinePrecision] + N[(0.16666666666666666 + N[(0.3333333333333333 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 1850.0], N[(1.0 / x), $MachinePrecision], If[LessEqual[x, 1.65e+180], N[(N[(N[(N[(y * 0.5 + -1.0), $MachinePrecision] * N[(y * N[(y * N[(y * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] / N[(y * N[(y * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(x * N[(1.0 / N[(x * (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -22000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5 + \left(\frac{0.5}{x} - y \cdot \left(\frac{0.5}{x} + \left(0.16666666666666666 + \frac{0.3333333333333333}{x \cdot x}\right)\right)\right), -1\right), 1\right)}{x}\\
\mathbf{elif}\;x \leq 1850:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{elif}\;x \leq 1.65 \cdot 10^{+180}:\\
\;\;\;\;\frac{\frac{\mathsf{fma}\left(\mathsf{fma}\left(y, 0.5, -1\right), y \cdot \left(y \cdot \mathsf{fma}\left(y, 0.5, -1\right)\right), -1\right)}{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5, -1\right), -1\right)}}{x}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{x \cdot \left(-x\right)}\\
\end{array}
\end{array}
if x < -22000Initial program 70.0%
Taylor expanded in y around 0
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites71.9%
if -22000 < x < 1850Initial program 87.8%
Taylor expanded in x around 0
Applied rewrites99.2%
if 1850 < x < 1.64999999999999995e180Initial program 82.7%
Taylor expanded in y around 0
lower-fma.f64N/A
sub-negN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6460.2
Applied rewrites60.2%
Taylor expanded in x around inf
Applied rewrites60.2%
Applied rewrites71.1%
if 1.64999999999999995e180 < x Initial program 52.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6429.5
Applied rewrites29.5%
Applied rewrites13.3%
Applied rewrites55.9%
Taylor expanded in y around 0
Applied rewrites55.9%
Final simplification83.5%
(FPCore (x y)
:precision binary64
(if (<= x -1.2e+154)
(/ (/ (- x (* x y)) x) x)
(if (<= x -5.8e+36)
(/ (+ x (* y (fma x (fma y 0.5 -1.0) (* y 0.5)))) (* x x))
(if (<= x 1.65e+180) (/ 1.0 x) (* x (/ 1.0 (* x (- x))))))))
double code(double x, double y) {
double tmp;
if (x <= -1.2e+154) {
tmp = ((x - (x * y)) / x) / x;
} else if (x <= -5.8e+36) {
tmp = (x + (y * fma(x, fma(y, 0.5, -1.0), (y * 0.5)))) / (x * x);
} else if (x <= 1.65e+180) {
tmp = 1.0 / x;
} else {
tmp = x * (1.0 / (x * -x));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -1.2e+154) tmp = Float64(Float64(Float64(x - Float64(x * y)) / x) / x); elseif (x <= -5.8e+36) tmp = Float64(Float64(x + Float64(y * fma(x, fma(y, 0.5, -1.0), Float64(y * 0.5)))) / Float64(x * x)); elseif (x <= 1.65e+180) tmp = Float64(1.0 / x); else tmp = Float64(x * Float64(1.0 / Float64(x * Float64(-x)))); end return tmp end
code[x_, y_] := If[LessEqual[x, -1.2e+154], N[(N[(N[(x - N[(x * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, -5.8e+36], N[(N[(x + N[(y * N[(x * N[(y * 0.5 + -1.0), $MachinePrecision] + N[(y * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.65e+180], N[(1.0 / x), $MachinePrecision], N[(x * N[(1.0 / N[(x * (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.2 \cdot 10^{+154}:\\
\;\;\;\;\frac{\frac{x - x \cdot y}{x}}{x}\\
\mathbf{elif}\;x \leq -5.8 \cdot 10^{+36}:\\
\;\;\;\;\frac{x + y \cdot \mathsf{fma}\left(x, \mathsf{fma}\left(y, 0.5, -1\right), y \cdot 0.5\right)}{x \cdot x}\\
\mathbf{elif}\;x \leq 1.65 \cdot 10^{+180}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{x \cdot \left(-x\right)}\\
\end{array}
\end{array}
if x < -1.20000000000000007e154Initial program 53.9%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
Applied rewrites62.5%
if -1.20000000000000007e154 < x < -5.8e36Initial program 85.3%
Taylor expanded in y around 0
lower-fma.f64N/A
sub-negN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6468.5
Applied rewrites68.5%
Taylor expanded in x around inf
Applied rewrites78.0%
Taylor expanded in x around 0
Applied rewrites87.8%
if -5.8e36 < x < 1.64999999999999995e180Initial program 87.1%
Taylor expanded in x around 0
Applied rewrites90.1%
if 1.64999999999999995e180 < x Initial program 52.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6429.5
Applied rewrites29.5%
Applied rewrites13.3%
Applied rewrites55.9%
Taylor expanded in y around 0
Applied rewrites55.9%
Final simplification82.4%
(FPCore (x y) :precision binary64 (if (<= x -22000.0) (* (fma y (fma y 0.5 -1.0) 1.0) (/ 1.0 x)) (if (<= x 1.65e+180) (/ 1.0 x) (* x (/ 1.0 (* x (- x)))))))
double code(double x, double y) {
double tmp;
if (x <= -22000.0) {
tmp = fma(y, fma(y, 0.5, -1.0), 1.0) * (1.0 / x);
} else if (x <= 1.65e+180) {
tmp = 1.0 / x;
} else {
tmp = x * (1.0 / (x * -x));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -22000.0) tmp = Float64(fma(y, fma(y, 0.5, -1.0), 1.0) * Float64(1.0 / x)); elseif (x <= 1.65e+180) tmp = Float64(1.0 / x); else tmp = Float64(x * Float64(1.0 / Float64(x * Float64(-x)))); end return tmp end
code[x_, y_] := If[LessEqual[x, -22000.0], N[(N[(y * N[(y * 0.5 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] * N[(1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.65e+180], N[(1.0 / x), $MachinePrecision], N[(x * N[(1.0 / N[(x * (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -22000:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5, -1\right), 1\right) \cdot \frac{1}{x}\\
\mathbf{elif}\;x \leq 1.65 \cdot 10^{+180}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{x \cdot \left(-x\right)}\\
\end{array}
\end{array}
if x < -22000Initial program 70.0%
Taylor expanded in y around 0
lower-fma.f64N/A
sub-negN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6460.1
Applied rewrites60.1%
Taylor expanded in x around inf
Applied rewrites67.9%
Applied rewrites68.0%
if -22000 < x < 1.64999999999999995e180Initial program 86.7%
Taylor expanded in x around 0
Applied rewrites90.4%
if 1.64999999999999995e180 < x Initial program 52.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6429.5
Applied rewrites29.5%
Applied rewrites13.3%
Applied rewrites55.9%
Taylor expanded in y around 0
Applied rewrites55.9%
Final simplification80.7%
(FPCore (x y) :precision binary64 (if (<= x -22000.0) (/ (fma y (fma y 0.5 -1.0) 1.0) x) (if (<= x 1.65e+180) (/ 1.0 x) (* x (/ 1.0 (* x (- x)))))))
double code(double x, double y) {
double tmp;
if (x <= -22000.0) {
tmp = fma(y, fma(y, 0.5, -1.0), 1.0) / x;
} else if (x <= 1.65e+180) {
tmp = 1.0 / x;
} else {
tmp = x * (1.0 / (x * -x));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -22000.0) tmp = Float64(fma(y, fma(y, 0.5, -1.0), 1.0) / x); elseif (x <= 1.65e+180) tmp = Float64(1.0 / x); else tmp = Float64(x * Float64(1.0 / Float64(x * Float64(-x)))); end return tmp end
code[x_, y_] := If[LessEqual[x, -22000.0], N[(N[(y * N[(y * 0.5 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 1.65e+180], N[(1.0 / x), $MachinePrecision], N[(x * N[(1.0 / N[(x * (-x)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -22000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5, -1\right), 1\right)}{x}\\
\mathbf{elif}\;x \leq 1.65 \cdot 10^{+180}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{x \cdot \left(-x\right)}\\
\end{array}
\end{array}
if x < -22000Initial program 70.0%
Taylor expanded in y around 0
lower-fma.f64N/A
sub-negN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6460.1
Applied rewrites60.1%
Taylor expanded in x around inf
Applied rewrites67.9%
if -22000 < x < 1.64999999999999995e180Initial program 86.7%
Taylor expanded in x around 0
Applied rewrites90.4%
if 1.64999999999999995e180 < x Initial program 52.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6429.5
Applied rewrites29.5%
Applied rewrites13.3%
Applied rewrites55.9%
Taylor expanded in y around 0
Applied rewrites55.9%
Final simplification80.7%
(FPCore (x y) :precision binary64 (if (<= x -22000.0) (/ (fma y (fma y 0.5 -1.0) 1.0) x) (/ 1.0 x)))
double code(double x, double y) {
double tmp;
if (x <= -22000.0) {
tmp = fma(y, fma(y, 0.5, -1.0), 1.0) / x;
} else {
tmp = 1.0 / x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -22000.0) tmp = Float64(fma(y, fma(y, 0.5, -1.0), 1.0) / x); else tmp = Float64(1.0 / x); end return tmp end
code[x_, y_] := If[LessEqual[x, -22000.0], N[(N[(y * N[(y * 0.5 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] / x), $MachinePrecision], N[(1.0 / x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -22000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5, -1\right), 1\right)}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{x}\\
\end{array}
\end{array}
if x < -22000Initial program 70.0%
Taylor expanded in y around 0
lower-fma.f64N/A
sub-negN/A
lower-fma.f64N/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f6460.1
Applied rewrites60.1%
Taylor expanded in x around inf
Applied rewrites67.9%
if -22000 < x Initial program 81.9%
Taylor expanded in x around 0
Applied rewrites82.0%
(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 78.6%
Taylor expanded in x around 0
Applied rewrites74.1%
(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 2024233
(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))