
(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 13 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 -42000.0) t_0 (if (<= x 0.000145) (/ 1.0 x) t_0))))
double code(double x, double y) {
double t_0 = exp(-y) / x;
double tmp;
if (x <= -42000.0) {
tmp = t_0;
} else if (x <= 0.000145) {
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 <= (-42000.0d0)) then
tmp = t_0
else if (x <= 0.000145d0) 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 <= -42000.0) {
tmp = t_0;
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = math.exp(-y) / x tmp = 0 if x <= -42000.0: tmp = t_0 elif x <= 0.000145: 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 <= -42000.0) tmp = t_0; elseif (x <= 0.000145) 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 <= -42000.0) tmp = t_0; elseif (x <= 0.000145) 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, -42000.0], t$95$0, If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{e^{-y}}{x}\\
\mathbf{if}\;x \leq -42000:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -42000 or 1.45e-4 < x Initial program 73.9%
Taylor expanded in x around inf
exp-lowering-exp.f64N/A
mul-1-negN/A
neg-lowering-neg.f64100.0
Simplified100.0%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
(FPCore (x y)
:precision binary64
(let* ((t_0
(/
(/
1.0
(fma
y
(fma
y
(+
0.5
(fma
y
(+
0.16666666666666666
(+ (/ 0.3333333333333333 (* x x)) (/ -0.5 x)))
(/ -0.5 x)))
1.0)
1.0))
x)))
(if (<= x -3.6e+261)
t_0
(if (<= x -42000.0)
(fma
y
(fma (/ y x) (fma y -0.16666666666666666 0.5) (/ -1.0 x))
(/ 1.0 x))
(if (<= x 0.000145) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = (1.0 / fma(y, fma(y, (0.5 + fma(y, (0.16666666666666666 + ((0.3333333333333333 / (x * x)) + (-0.5 / x))), (-0.5 / x))), 1.0), 1.0)) / x;
double tmp;
if (x <= -3.6e+261) {
tmp = t_0;
} else if (x <= -42000.0) {
tmp = fma(y, fma((y / x), fma(y, -0.16666666666666666, 0.5), (-1.0 / x)), (1.0 / x));
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(Float64(1.0 / fma(y, fma(y, Float64(0.5 + fma(y, Float64(0.16666666666666666 + Float64(Float64(0.3333333333333333 / Float64(x * x)) + Float64(-0.5 / x))), Float64(-0.5 / x))), 1.0), 1.0)) / x) tmp = 0.0 if (x <= -3.6e+261) tmp = t_0; elseif (x <= -42000.0) tmp = fma(y, fma(Float64(y / x), fma(y, -0.16666666666666666, 0.5), Float64(-1.0 / x)), Float64(1.0 / x)); elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(N[(1.0 / N[(y * N[(y * N[(0.5 + N[(y * N[(0.16666666666666666 + N[(N[(0.3333333333333333 / N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]}, If[LessEqual[x, -3.6e+261], t$95$0, If[LessEqual[x, -42000.0], N[(y * N[(N[(y / x), $MachinePrecision] * N[(y * -0.16666666666666666 + 0.5), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{1}{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 0.5 + \mathsf{fma}\left(y, 0.16666666666666666 + \left(\frac{0.3333333333333333}{x \cdot x} + \frac{-0.5}{x}\right), \frac{-0.5}{x}\right), 1\right), 1\right)}}{x}\\
\mathbf{if}\;x \leq -3.6 \cdot 10^{+261}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(\frac{y}{x}, \mathsf{fma}\left(y, -0.16666666666666666, 0.5\right), \frac{-1}{x}\right), \frac{1}{x}\right)\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -3.60000000000000018e261 or 1.45e-4 < x Initial program 68.2%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6468.2
Applied egg-rr68.2%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified80.6%
if -3.60000000000000018e261 < x < -42000Initial program 83.9%
Taylor expanded in x around inf
exp-lowering-exp.f64N/A
mul-1-negN/A
neg-lowering-neg.f64100.0
Simplified100.0%
Taylor expanded in y around 0
accelerator-lowering-fma.f64N/A
Simplified82.3%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
(FPCore (x y)
:precision binary64
(let* ((t_0
(/
-1.0
(* x (fma y (fma y (fma y -0.16666666666666666 0.5) -1.0) -1.0)))))
(if (<= x -3.9e+261)
t_0
(if (<= x -42000.0)
(fma
y
(fma (/ y x) (fma y -0.16666666666666666 0.5) (/ -1.0 x))
(/ 1.0 x))
(if (<= x 0.000145) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = -1.0 / (x * fma(y, fma(y, fma(y, -0.16666666666666666, 0.5), -1.0), -1.0));
double tmp;
if (x <= -3.9e+261) {
tmp = t_0;
} else if (x <= -42000.0) {
tmp = fma(y, fma((y / x), fma(y, -0.16666666666666666, 0.5), (-1.0 / x)), (1.0 / x));
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(x * fma(y, fma(y, fma(y, -0.16666666666666666, 0.5), -1.0), -1.0))) tmp = 0.0 if (x <= -3.9e+261) tmp = t_0; elseif (x <= -42000.0) tmp = fma(y, fma(Float64(y / x), fma(y, -0.16666666666666666, 0.5), Float64(-1.0 / x)), Float64(1.0 / x)); elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 / N[(x * N[(y * N[(y * N[(y * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.9e+261], t$95$0, If[LessEqual[x, -42000.0], N[(y * N[(N[(y / x), $MachinePrecision] * N[(y * -0.16666666666666666 + 0.5), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-1}{x \cdot \mathsf{fma}\left(y, \mathsf{fma}\left(y, \mathsf{fma}\left(y, -0.16666666666666666, 0.5\right), -1\right), -1\right)}\\
\mathbf{if}\;x \leq -3.9 \cdot 10^{+261}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(\frac{y}{x}, \mathsf{fma}\left(y, -0.16666666666666666, 0.5\right), \frac{-1}{x}\right), \frac{1}{x}\right)\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -3.89999999999999994e261 or 1.45e-4 < x Initial program 68.2%
Taylor expanded in x around inf
exp-lowering-exp.f64N/A
mul-1-negN/A
neg-lowering-neg.f64100.0
Simplified100.0%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6462.5
Simplified62.5%
div-invN/A
flip-+N/A
frac-timesN/A
*-rgt-identityN/A
/-lowering-/.f64N/A
Applied egg-rr57.2%
Taylor expanded in y around 0
Simplified80.2%
if -3.89999999999999994e261 < x < -42000Initial program 83.9%
Taylor expanded in x around inf
exp-lowering-exp.f64N/A
mul-1-negN/A
neg-lowering-neg.f64100.0
Simplified100.0%
Taylor expanded in y around 0
accelerator-lowering-fma.f64N/A
Simplified82.3%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
Final simplification87.3%
(FPCore (x y)
:precision binary64
(let* ((t_0
(/
-1.0
(* x (fma y (fma y (fma y -0.16666666666666666 0.5) -1.0) -1.0)))))
(if (<= x -7.6e+261)
t_0
(if (<= x -42000.0)
(fma y (/ (- y (* y y)) x) (/ (- 1.0 y) x))
(if (<= x 0.000145) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = -1.0 / (x * fma(y, fma(y, fma(y, -0.16666666666666666, 0.5), -1.0), -1.0));
double tmp;
if (x <= -7.6e+261) {
tmp = t_0;
} else if (x <= -42000.0) {
tmp = fma(y, ((y - (y * y)) / x), ((1.0 - y) / x));
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(x * fma(y, fma(y, fma(y, -0.16666666666666666, 0.5), -1.0), -1.0))) tmp = 0.0 if (x <= -7.6e+261) tmp = t_0; elseif (x <= -42000.0) tmp = fma(y, Float64(Float64(y - Float64(y * y)) / x), Float64(Float64(1.0 - y) / x)); elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 / N[(x * N[(y * N[(y * N[(y * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.6e+261], t$95$0, If[LessEqual[x, -42000.0], N[(y * N[(N[(y - N[(y * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] + N[(N[(1.0 - y), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-1}{x \cdot \mathsf{fma}\left(y, \mathsf{fma}\left(y, \mathsf{fma}\left(y, -0.16666666666666666, 0.5\right), -1\right), -1\right)}\\
\mathbf{if}\;x \leq -7.6 \cdot 10^{+261}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{y - y \cdot y}{x}, \frac{1 - y}{x}\right)\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -7.6000000000000003e261 or 1.45e-4 < x Initial program 68.2%
Taylor expanded in x around inf
exp-lowering-exp.f64N/A
mul-1-negN/A
neg-lowering-neg.f64100.0
Simplified100.0%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6462.5
Simplified62.5%
div-invN/A
flip-+N/A
frac-timesN/A
*-rgt-identityN/A
/-lowering-/.f64N/A
Applied egg-rr57.2%
Taylor expanded in y around 0
Simplified80.2%
if -7.6000000000000003e261 < x < -42000Initial program 83.9%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6483.9
Applied egg-rr83.9%
Taylor expanded in y around 0
+-lowering-+.f6460.8
Simplified60.8%
Taylor expanded in y around 0
sub-negN/A
distribute-lft-inN/A
associate-+l+N/A
distribute-rgt-neg-inN/A
associate-*r/N/A
*-rgt-identityN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
Simplified82.3%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
Final simplification87.3%
(FPCore (x y)
:precision binary64
(let* ((t_0
(/
-1.0
(* x (fma y (fma y (fma y -0.16666666666666666 0.5) -1.0) -1.0)))))
(if (<= x -1.1e+262)
t_0
(if (<= x -42000.0)
(/ (fma y (fma y (- 1.0 y) -1.0) 1.0) x)
(if (<= x 0.000145) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = -1.0 / (x * fma(y, fma(y, fma(y, -0.16666666666666666, 0.5), -1.0), -1.0));
double tmp;
if (x <= -1.1e+262) {
tmp = t_0;
} else if (x <= -42000.0) {
tmp = fma(y, fma(y, (1.0 - y), -1.0), 1.0) / x;
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(x * fma(y, fma(y, fma(y, -0.16666666666666666, 0.5), -1.0), -1.0))) tmp = 0.0 if (x <= -1.1e+262) tmp = t_0; elseif (x <= -42000.0) tmp = Float64(fma(y, fma(y, Float64(1.0 - y), -1.0), 1.0) / x); elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 / N[(x * N[(y * N[(y * N[(y * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.1e+262], t$95$0, If[LessEqual[x, -42000.0], N[(N[(y * N[(y * N[(1.0 - y), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-1}{x \cdot \mathsf{fma}\left(y, \mathsf{fma}\left(y, \mathsf{fma}\left(y, -0.16666666666666666, 0.5\right), -1\right), -1\right)}\\
\mathbf{if}\;x \leq -1.1 \cdot 10^{+262}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 1 - y, -1\right), 1\right)}{x}\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -1.10000000000000005e262 or 1.45e-4 < x Initial program 68.2%
Taylor expanded in x around inf
exp-lowering-exp.f64N/A
mul-1-negN/A
neg-lowering-neg.f64100.0
Simplified100.0%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6462.5
Simplified62.5%
div-invN/A
flip-+N/A
frac-timesN/A
*-rgt-identityN/A
/-lowering-/.f64N/A
Applied egg-rr57.2%
Taylor expanded in y around 0
Simplified80.2%
if -1.10000000000000005e262 < x < -42000Initial program 83.9%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6483.9
Applied egg-rr83.9%
Taylor expanded in y around 0
+-lowering-+.f6460.8
Simplified60.8%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
--lowering--.f6482.3
Simplified82.3%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
Final simplification87.3%
(FPCore (x y)
:precision binary64
(if (<= x -6e+261)
(/ 1.0 (fma y x x))
(if (<= x -42000.0)
(/ (fma y (fma y (- 1.0 y) -1.0) 1.0) x)
(if (<= x 0.000145) (/ 1.0 x) (/ (/ (- 1.0 y) (- 1.0 (* y y))) x)))))
double code(double x, double y) {
double tmp;
if (x <= -6e+261) {
tmp = 1.0 / fma(y, x, x);
} else if (x <= -42000.0) {
tmp = fma(y, fma(y, (1.0 - y), -1.0), 1.0) / x;
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = ((1.0 - y) / (1.0 - (y * y))) / x;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -6e+261) tmp = Float64(1.0 / fma(y, x, x)); elseif (x <= -42000.0) tmp = Float64(fma(y, fma(y, Float64(1.0 - y), -1.0), 1.0) / x); elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = Float64(Float64(Float64(1.0 - y) / Float64(1.0 - Float64(y * y))) / x); end return tmp end
code[x_, y_] := If[LessEqual[x, -6e+261], N[(1.0 / N[(y * x + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -42000.0], N[(N[(y * N[(y * N[(1.0 - y), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], N[(N[(N[(1.0 - y), $MachinePrecision] / N[(1.0 - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6 \cdot 10^{+261}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(y, x, x\right)}\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 1 - y, -1\right), 1\right)}{x}\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 - y}{1 - y \cdot y}}{x}\\
\end{array}
\end{array}
if x < -5.99999999999999957e261Initial program 45.6%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6445.6
Applied egg-rr45.6%
Taylor expanded in y around 0
+-lowering-+.f6483.0
Simplified83.0%
associate-/l/N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt1-inN/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f6483.0
Applied egg-rr83.0%
if -5.99999999999999957e261 < x < -42000Initial program 83.9%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6483.9
Applied egg-rr83.9%
Taylor expanded in y around 0
+-lowering-+.f6460.8
Simplified60.8%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
--lowering--.f6482.3
Simplified82.3%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
if 1.45e-4 < x Initial program 72.6%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6472.6
Applied egg-rr72.6%
Taylor expanded in y around 0
+-lowering-+.f6473.7
Simplified73.7%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f6475.4
Applied egg-rr75.4%
(FPCore (x y)
:precision binary64
(if (<= x -1.05e+262)
(/ 1.0 (fma y x x))
(if (<= x -42000.0)
(/ (fma y (fma y (- 1.0 y) -1.0) 1.0) x)
(if (<= x 0.00014) (/ 1.0 x) (/ -1.0 (* x (- -1.0 y)))))))
double code(double x, double y) {
double tmp;
if (x <= -1.05e+262) {
tmp = 1.0 / fma(y, x, x);
} else if (x <= -42000.0) {
tmp = fma(y, fma(y, (1.0 - y), -1.0), 1.0) / x;
} else if (x <= 0.00014) {
tmp = 1.0 / x;
} else {
tmp = -1.0 / (x * (-1.0 - y));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -1.05e+262) tmp = Float64(1.0 / fma(y, x, x)); elseif (x <= -42000.0) tmp = Float64(fma(y, fma(y, Float64(1.0 - y), -1.0), 1.0) / x); elseif (x <= 0.00014) tmp = Float64(1.0 / x); else tmp = Float64(-1.0 / Float64(x * Float64(-1.0 - y))); end return tmp end
code[x_, y_] := If[LessEqual[x, -1.05e+262], N[(1.0 / N[(y * x + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -42000.0], N[(N[(y * N[(y * N[(1.0 - y), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 0.00014], N[(1.0 / x), $MachinePrecision], N[(-1.0 / N[(x * N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.05 \cdot 10^{+262}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(y, x, x\right)}\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \mathsf{fma}\left(y, 1 - y, -1\right), 1\right)}{x}\\
\mathbf{elif}\;x \leq 0.00014:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{x \cdot \left(-1 - y\right)}\\
\end{array}
\end{array}
if x < -1.04999999999999995e262Initial program 45.6%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6445.6
Applied egg-rr45.6%
Taylor expanded in y around 0
+-lowering-+.f6483.0
Simplified83.0%
associate-/l/N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt1-inN/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f6483.0
Applied egg-rr83.0%
if -1.04999999999999995e262 < x < -42000Initial program 83.9%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6483.9
Applied egg-rr83.9%
Taylor expanded in y around 0
+-lowering-+.f6460.8
Simplified60.8%
Taylor expanded in y around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
--lowering--.f6482.3
Simplified82.3%
if -42000 < x < 1.3999999999999999e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
if 1.3999999999999999e-4 < x Initial program 72.6%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6472.6
Applied egg-rr72.6%
Taylor expanded in y around 0
+-lowering-+.f6473.7
Simplified73.7%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
distribute-neg-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
neg-lowering-neg.f6475.2
Applied egg-rr75.2%
Final simplification85.8%
(FPCore (x y)
:precision binary64
(if (<= x -4.8e+261)
(/ 1.0 (fma y x x))
(if (<= x -42000.0)
(/ (fma y y (- 1.0 y)) x)
(if (<= x 0.000145) (/ 1.0 x) (/ -1.0 (* x (- -1.0 y)))))))
double code(double x, double y) {
double tmp;
if (x <= -4.8e+261) {
tmp = 1.0 / fma(y, x, x);
} else if (x <= -42000.0) {
tmp = fma(y, y, (1.0 - y)) / x;
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = -1.0 / (x * (-1.0 - y));
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= -4.8e+261) tmp = Float64(1.0 / fma(y, x, x)); elseif (x <= -42000.0) tmp = Float64(fma(y, y, Float64(1.0 - y)) / x); elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = Float64(-1.0 / Float64(x * Float64(-1.0 - y))); end return tmp end
code[x_, y_] := If[LessEqual[x, -4.8e+261], N[(1.0 / N[(y * x + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -42000.0], N[(N[(y * y + N[(1.0 - y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], N[(-1.0 / N[(x * N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -4.8 \cdot 10^{+261}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(y, x, x\right)}\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, y, 1 - y\right)}{x}\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{x \cdot \left(-1 - y\right)}\\
\end{array}
\end{array}
if x < -4.7999999999999997e261Initial program 45.6%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6445.6
Applied egg-rr45.6%
Taylor expanded in y around 0
+-lowering-+.f6483.0
Simplified83.0%
associate-/l/N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt1-inN/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f6483.0
Applied egg-rr83.0%
if -4.7999999999999997e261 < x < -42000Initial program 83.9%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6483.9
Applied egg-rr83.9%
Taylor expanded in y around 0
+-lowering-+.f6460.8
Simplified60.8%
Taylor expanded in y around 0
+-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-rgt-inN/A
unpow2N/A
associate-+l+N/A
unpow2N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
--lowering--.f6479.1
Simplified79.1%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
if 1.45e-4 < x Initial program 72.6%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6472.6
Applied egg-rr72.6%
Taylor expanded in y around 0
+-lowering-+.f6473.7
Simplified73.7%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
distribute-neg-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
neg-lowering-neg.f6475.2
Applied egg-rr75.2%
Final simplification85.1%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ 1.0 (fma y x x))))
(if (<= x -5e+261)
t_0
(if (<= x -42000.0)
(/ (fma y y (- 1.0 y)) x)
(if (<= x 0.000145) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = 1.0 / fma(y, x, x);
double tmp;
if (x <= -5e+261) {
tmp = t_0;
} else if (x <= -42000.0) {
tmp = fma(y, y, (1.0 - y)) / x;
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(1.0 / fma(y, x, x)) tmp = 0.0 if (x <= -5e+261) tmp = t_0; elseif (x <= -42000.0) tmp = Float64(fma(y, y, Float64(1.0 - y)) / x); elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[(y * x + x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5e+261], t$95$0, If[LessEqual[x, -42000.0], N[(N[(y * y + N[(1.0 - y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{\mathsf{fma}\left(y, x, x\right)}\\
\mathbf{if}\;x \leq -5 \cdot 10^{+261}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -42000:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, y, 1 - y\right)}{x}\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -5.0000000000000001e261 or 1.45e-4 < x Initial program 68.2%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6468.2
Applied egg-rr68.2%
Taylor expanded in y around 0
+-lowering-+.f6475.2
Simplified75.2%
associate-/l/N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt1-inN/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f6476.5
Applied egg-rr76.5%
if -5.0000000000000001e261 < x < -42000Initial program 83.9%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6483.9
Applied egg-rr83.9%
Taylor expanded in y around 0
+-lowering-+.f6460.8
Simplified60.8%
Taylor expanded in y around 0
+-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-rgt-inN/A
unpow2N/A
associate-+l+N/A
unpow2N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
--lowering--.f6479.1
Simplified79.1%
if -42000 < x < 1.45e-4Initial program 79.1%
Taylor expanded in x around 0
Simplified98.7%
(FPCore (x y) :precision binary64 (let* ((t_0 (/ 1.0 (fma y x x)))) (if (<= x -7.2e+176) t_0 (if (<= x 0.000145) (/ 1.0 x) t_0))))
double code(double x, double y) {
double t_0 = 1.0 / fma(y, x, x);
double tmp;
if (x <= -7.2e+176) {
tmp = t_0;
} else if (x <= 0.000145) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(1.0 / fma(y, x, x)) tmp = 0.0 if (x <= -7.2e+176) tmp = t_0; elseif (x <= 0.000145) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[(y * x + x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.2e+176], t$95$0, If[LessEqual[x, 0.000145], N[(1.0 / x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{\mathsf{fma}\left(y, x, x\right)}\\
\mathbf{if}\;x \leq -7.2 \cdot 10^{+176}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 0.000145:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -7.19999999999999983e176 or 1.45e-4 < x Initial program 67.3%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6467.3
Applied egg-rr67.3%
Taylor expanded in y around 0
+-lowering-+.f6472.5
Simplified72.5%
associate-/l/N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt1-inN/A
/-lowering-/.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f6473.6
Applied egg-rr73.6%
if -7.19999999999999983e176 < x < 1.45e-4Initial program 83.5%
Taylor expanded in x around 0
Simplified87.5%
(FPCore (x y) :precision binary64 (if (<= y 135.0) (/ 1.0 x) (/ x (* x x))))
double code(double x, double y) {
double tmp;
if (y <= 135.0) {
tmp = 1.0 / x;
} else {
tmp = x / (x * x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 135.0d0) then
tmp = 1.0d0 / x
else
tmp = x / (x * x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 135.0) {
tmp = 1.0 / x;
} else {
tmp = x / (x * x);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 135.0: tmp = 1.0 / x else: tmp = x / (x * x) return tmp
function code(x, y) tmp = 0.0 if (y <= 135.0) tmp = Float64(1.0 / x); else tmp = Float64(x / Float64(x * x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 135.0) tmp = 1.0 / x; else tmp = x / (x * x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 135.0], N[(1.0 / x), $MachinePrecision], N[(x / N[(x * x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 135:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{x \cdot x}\\
\end{array}
\end{array}
if y < 135Initial program 84.8%
Taylor expanded in x around 0
Simplified82.2%
if 135 < y Initial program 41.1%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f642.7
Simplified2.7%
frac-subN/A
/-lowering-/.f64N/A
*-lft-identityN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6412.0
Applied egg-rr12.0%
Taylor expanded in y around 0
Simplified63.1%
(FPCore (x y) :precision binary64 (if (<= y 3.2e+92) (/ 1.0 x) (/ 1.0 (* x y))))
double code(double x, double y) {
double tmp;
if (y <= 3.2e+92) {
tmp = 1.0 / x;
} 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 <= 3.2d+92) then
tmp = 1.0d0 / x
else
tmp = 1.0d0 / (x * y)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= 3.2e+92) {
tmp = 1.0 / x;
} else {
tmp = 1.0 / (x * y);
}
return tmp;
}
def code(x, y): tmp = 0 if y <= 3.2e+92: tmp = 1.0 / x else: tmp = 1.0 / (x * y) return tmp
function code(x, y) tmp = 0.0 if (y <= 3.2e+92) tmp = Float64(1.0 / x); else tmp = Float64(1.0 / Float64(x * y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= 3.2e+92) tmp = 1.0 / x; else tmp = 1.0 / (x * y); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, 3.2e+92], N[(1.0 / x), $MachinePrecision], N[(1.0 / N[(x * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.2 \cdot 10^{+92}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{x \cdot y}\\
\end{array}
\end{array}
if y < 3.20000000000000025e92Initial program 81.3%
Taylor expanded in x around 0
Simplified78.6%
if 3.20000000000000025e92 < y Initial program 42.1%
*-commutativeN/A
exp-to-powN/A
remove-double-negN/A
pow-flipN/A
pow-flipN/A
exp-to-powN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
inv-powN/A
clear-numN/A
pow-lowering-pow.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6439.5
Applied egg-rr39.5%
Taylor expanded in y around 0
+-lowering-+.f6453.8
Simplified53.8%
Taylor expanded in y around inf
/-lowering-/.f64N/A
*-lowering-*.f6457.5
Simplified57.5%
(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 75.8%
Taylor expanded in x around 0
Simplified72.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 2024205
(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))