
(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 10 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 -0.64) t_0 (if (<= x 7e-7) (/ 1.0 x) t_0))))
double code(double x, double y) {
double t_0 = exp(-y) / x;
double tmp;
if (x <= -0.64) {
tmp = t_0;
} else if (x <= 7e-7) {
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 <= (-0.64d0)) then
tmp = t_0
else if (x <= 7d-7) 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 <= -0.64) {
tmp = t_0;
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = math.exp(-y) / x tmp = 0 if x <= -0.64: tmp = t_0 elif x <= 7e-7: 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 <= -0.64) tmp = t_0; elseif (x <= 7e-7) 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 <= -0.64) tmp = t_0; elseif (x <= 7e-7) 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, -0.64], t$95$0, If[LessEqual[x, 7e-7], N[(1.0 / x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{e^{-y}}{x}\\
\mathbf{if}\;x \leq -0.64:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -0.640000000000000013 or 6.99999999999999968e-7 < x Initial program 77.5%
Taylor expanded in y around 0
mul-1-negN/A
lower-neg.f6499.5
Applied rewrites99.5%
if -0.640000000000000013 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
(FPCore (x y)
:precision binary64
(let* ((t_0 (- 0.5 (/ 0.5 x))) (t_1 (/ 0.3333333333333333 (* x x))))
(if (<= x -7.4e+168)
(/
-1.0
(fma
(fma
(* (fma (- (+ 0.16666666666666666 t_1) (/ 0.5 x)) y t_0) (- x))
y
(- x))
y
(- x)))
(if (<= x -1.85)
(*
(fma
(fma
(fma (+ (+ (/ 0.5 x) 0.16666666666666666) t_1) y (- -0.5 (/ 0.5 x)))
y
1.0)
y
-1.0)
(/ -1.0 x))
(if (<= x 7e-7)
(/ 1.0 x)
(/ -1.0 (* (fma (fma t_0 y 1.0) y 1.0) (- x))))))))
double code(double x, double y) {
double t_0 = 0.5 - (0.5 / x);
double t_1 = 0.3333333333333333 / (x * x);
double tmp;
if (x <= -7.4e+168) {
tmp = -1.0 / fma(fma((fma(((0.16666666666666666 + t_1) - (0.5 / x)), y, t_0) * -x), y, -x), y, -x);
} else if (x <= -1.85) {
tmp = fma(fma(fma((((0.5 / x) + 0.16666666666666666) + t_1), y, (-0.5 - (0.5 / x))), y, 1.0), y, -1.0) * (-1.0 / x);
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = -1.0 / (fma(fma(t_0, y, 1.0), y, 1.0) * -x);
}
return tmp;
}
function code(x, y) t_0 = Float64(0.5 - Float64(0.5 / x)) t_1 = Float64(0.3333333333333333 / Float64(x * x)) tmp = 0.0 if (x <= -7.4e+168) tmp = Float64(-1.0 / fma(fma(Float64(fma(Float64(Float64(0.16666666666666666 + t_1) - Float64(0.5 / x)), y, t_0) * Float64(-x)), y, Float64(-x)), y, Float64(-x))); elseif (x <= -1.85) tmp = Float64(fma(fma(fma(Float64(Float64(Float64(0.5 / x) + 0.16666666666666666) + t_1), y, Float64(-0.5 - Float64(0.5 / x))), y, 1.0), y, -1.0) * Float64(-1.0 / x)); elseif (x <= 7e-7) tmp = Float64(1.0 / x); else tmp = Float64(-1.0 / Float64(fma(fma(t_0, y, 1.0), y, 1.0) * Float64(-x))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.3333333333333333 / N[(x * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.4e+168], N[(-1.0 / N[(N[(N[(N[(N[(N[(0.16666666666666666 + t$95$1), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision] * y + t$95$0), $MachinePrecision] * (-x)), $MachinePrecision] * y + (-x)), $MachinePrecision] * y + (-x)), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.85], N[(N[(N[(N[(N[(N[(N[(0.5 / x), $MachinePrecision] + 0.16666666666666666), $MachinePrecision] + t$95$1), $MachinePrecision] * y + N[(-0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + -1.0), $MachinePrecision] * N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7e-7], N[(1.0 / x), $MachinePrecision], N[(-1.0 / N[(N[(N[(t$95$0 * y + 1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] * (-x)), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 0.5 - \frac{0.5}{x}\\
t_1 := \frac{0.3333333333333333}{x \cdot x}\\
\mathbf{if}\;x \leq -7.4 \cdot 10^{+168}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\left(0.16666666666666666 + t\_1\right) - \frac{0.5}{x}, y, t\_0\right) \cdot \left(-x\right), y, -x\right), y, -x\right)}\\
\mathbf{elif}\;x \leq -1.85:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\left(\frac{0.5}{x} + 0.16666666666666666\right) + t\_1, y, -0.5 - \frac{0.5}{x}\right), y, 1\right), y, -1\right) \cdot \frac{-1}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(\mathsf{fma}\left(t\_0, y, 1\right), y, 1\right) \cdot \left(-x\right)}\\
\end{array}
\end{array}
if x < -7.40000000000000018e168Initial program 55.4%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites55.4%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites74.7%
if -7.40000000000000018e168 < x < -1.8500000000000001Initial program 91.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
associate-/r/N/A
lower-*.f64N/A
metadata-evalN/A
frac-2negN/A
lower-/.f64N/A
lower-neg.f6491.5
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
lower-pow.f6491.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6491.6
Applied rewrites91.6%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
Applied rewrites85.1%
if -1.8500000000000001 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
if 6.99999999999999968e-7 < x Initial program 77.9%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites77.9%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6480.9
Applied rewrites80.9%
Final simplification86.6%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ 0.3333333333333333 (* x x))) (t_1 (- 0.5 (/ 0.5 x))))
(if (<= x -7.4e+168)
(/
(- -1.0)
(*
(fma
(fma (fma (- (+ 0.16666666666666666 t_0) (/ 0.5 x)) y t_1) y 1.0)
y
1.0)
x))
(if (<= x -1.85)
(*
(fma
(fma
(fma (+ (+ (/ 0.5 x) 0.16666666666666666) t_0) y (- -0.5 (/ 0.5 x)))
y
1.0)
y
-1.0)
(/ -1.0 x))
(if (<= x 7e-7)
(/ 1.0 x)
(/ -1.0 (* (fma (fma t_1 y 1.0) y 1.0) (- x))))))))
double code(double x, double y) {
double t_0 = 0.3333333333333333 / (x * x);
double t_1 = 0.5 - (0.5 / x);
double tmp;
if (x <= -7.4e+168) {
tmp = -(-1.0) / (fma(fma(fma(((0.16666666666666666 + t_0) - (0.5 / x)), y, t_1), y, 1.0), y, 1.0) * x);
} else if (x <= -1.85) {
tmp = fma(fma(fma((((0.5 / x) + 0.16666666666666666) + t_0), y, (-0.5 - (0.5 / x))), y, 1.0), y, -1.0) * (-1.0 / x);
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = -1.0 / (fma(fma(t_1, y, 1.0), y, 1.0) * -x);
}
return tmp;
}
function code(x, y) t_0 = Float64(0.3333333333333333 / Float64(x * x)) t_1 = Float64(0.5 - Float64(0.5 / x)) tmp = 0.0 if (x <= -7.4e+168) tmp = Float64(Float64(-(-1.0)) / Float64(fma(fma(fma(Float64(Float64(0.16666666666666666 + t_0) - Float64(0.5 / x)), y, t_1), y, 1.0), y, 1.0) * x)); elseif (x <= -1.85) tmp = Float64(fma(fma(fma(Float64(Float64(Float64(0.5 / x) + 0.16666666666666666) + t_0), y, Float64(-0.5 - Float64(0.5 / x))), y, 1.0), y, -1.0) * Float64(-1.0 / x)); elseif (x <= 7e-7) tmp = Float64(1.0 / x); else tmp = Float64(-1.0 / Float64(fma(fma(t_1, y, 1.0), y, 1.0) * Float64(-x))); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(0.3333333333333333 / N[(x * x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.4e+168], N[((--1.0) / N[(N[(N[(N[(N[(N[(0.16666666666666666 + t$95$0), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision] * y + t$95$1), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.85], N[(N[(N[(N[(N[(N[(N[(0.5 / x), $MachinePrecision] + 0.16666666666666666), $MachinePrecision] + t$95$0), $MachinePrecision] * y + N[(-0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + -1.0), $MachinePrecision] * N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7e-7], N[(1.0 / x), $MachinePrecision], N[(-1.0 / N[(N[(N[(t$95$1 * y + 1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] * (-x)), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{0.3333333333333333}{x \cdot x}\\
t_1 := 0.5 - \frac{0.5}{x}\\
\mathbf{if}\;x \leq -7.4 \cdot 10^{+168}:\\
\;\;\;\;\frac{--1}{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\left(0.16666666666666666 + t\_0\right) - \frac{0.5}{x}, y, t\_1\right), y, 1\right), y, 1\right) \cdot x}\\
\mathbf{elif}\;x \leq -1.85:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\left(\frac{0.5}{x} + 0.16666666666666666\right) + t\_0, y, -0.5 - \frac{0.5}{x}\right), y, 1\right), y, -1\right) \cdot \frac{-1}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(\mathsf{fma}\left(t\_1, y, 1\right), y, 1\right) \cdot \left(-x\right)}\\
\end{array}
\end{array}
if x < -7.40000000000000018e168Initial program 55.4%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites55.4%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites74.7%
if -7.40000000000000018e168 < x < -1.8500000000000001Initial program 91.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
associate-/r/N/A
lower-*.f64N/A
metadata-evalN/A
frac-2negN/A
lower-/.f64N/A
lower-neg.f6491.5
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
lower-pow.f6491.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6491.6
Applied rewrites91.6%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
Applied rewrites85.1%
if -1.8500000000000001 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
if 6.99999999999999968e-7 < x Initial program 77.9%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites77.9%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6480.9
Applied rewrites80.9%
Final simplification86.6%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ -1.0 (* (fma (fma (- 0.5 (/ 0.5 x)) y 1.0) y 1.0) (- x)))))
(if (<= x -7.8e+168)
t_0
(if (<= x -1.85)
(*
(fma
(fma
(fma
(+ (+ (/ 0.5 x) 0.16666666666666666) (/ 0.3333333333333333 (* x x)))
y
(- -0.5 (/ 0.5 x)))
y
1.0)
y
-1.0)
(/ -1.0 x))
(if (<= x 7e-7) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = -1.0 / (fma(fma((0.5 - (0.5 / x)), y, 1.0), y, 1.0) * -x);
double tmp;
if (x <= -7.8e+168) {
tmp = t_0;
} else if (x <= -1.85) {
tmp = fma(fma(fma((((0.5 / x) + 0.16666666666666666) + (0.3333333333333333 / (x * x))), y, (-0.5 - (0.5 / x))), y, 1.0), y, -1.0) * (-1.0 / x);
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(fma(fma(Float64(0.5 - Float64(0.5 / x)), y, 1.0), y, 1.0) * Float64(-x))) tmp = 0.0 if (x <= -7.8e+168) tmp = t_0; elseif (x <= -1.85) tmp = Float64(fma(fma(fma(Float64(Float64(Float64(0.5 / x) + 0.16666666666666666) + Float64(0.3333333333333333 / Float64(x * x))), y, Float64(-0.5 - Float64(0.5 / x))), y, 1.0), y, -1.0) * Float64(-1.0 / x)); elseif (x <= 7e-7) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 / N[(N[(N[(N[(0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] * (-x)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.8e+168], t$95$0, If[LessEqual[x, -1.85], N[(N[(N[(N[(N[(N[(N[(0.5 / x), $MachinePrecision] + 0.16666666666666666), $MachinePrecision] + N[(0.3333333333333333 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y + N[(-0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + -1.0), $MachinePrecision] * N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7e-7], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-1}{\mathsf{fma}\left(\mathsf{fma}\left(0.5 - \frac{0.5}{x}, y, 1\right), y, 1\right) \cdot \left(-x\right)}\\
\mathbf{if}\;x \leq -7.8 \cdot 10^{+168}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -1.85:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\left(\frac{0.5}{x} + 0.16666666666666666\right) + \frac{0.3333333333333333}{x \cdot x}, y, -0.5 - \frac{0.5}{x}\right), y, 1\right), y, -1\right) \cdot \frac{-1}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -7.79999999999999999e168 or 6.99999999999999968e-7 < x Initial program 71.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites71.5%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6479.0
Applied rewrites79.0%
if -7.79999999999999999e168 < x < -1.8500000000000001Initial program 91.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
associate-/r/N/A
lower-*.f64N/A
metadata-evalN/A
frac-2negN/A
lower-/.f64N/A
lower-neg.f6491.5
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
lower-pow.f6491.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6491.6
Applied rewrites91.6%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
Applied rewrites85.1%
if -1.8500000000000001 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
Final simplification86.5%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ -1.0 (* (fma (fma (- 0.5 (/ 0.5 x)) y 1.0) y 1.0) (- x)))))
(if (<= x -7.8e+168)
t_0
(if (<= x -1.85)
(/
(fma
(fma
(fma
(+ (+ (/ 0.5 x) 0.16666666666666666) (/ 0.3333333333333333 (* x x)))
(- y)
(+ (/ 0.5 x) 0.5))
y
-1.0)
y
1.0)
x)
(if (<= x 7e-7) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = -1.0 / (fma(fma((0.5 - (0.5 / x)), y, 1.0), y, 1.0) * -x);
double tmp;
if (x <= -7.8e+168) {
tmp = t_0;
} else if (x <= -1.85) {
tmp = fma(fma(fma((((0.5 / x) + 0.16666666666666666) + (0.3333333333333333 / (x * x))), -y, ((0.5 / x) + 0.5)), y, -1.0), y, 1.0) / x;
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(fma(fma(Float64(0.5 - Float64(0.5 / x)), y, 1.0), y, 1.0) * Float64(-x))) tmp = 0.0 if (x <= -7.8e+168) tmp = t_0; elseif (x <= -1.85) tmp = Float64(fma(fma(fma(Float64(Float64(Float64(0.5 / x) + 0.16666666666666666) + Float64(0.3333333333333333 / Float64(x * x))), Float64(-y), Float64(Float64(0.5 / x) + 0.5)), y, -1.0), y, 1.0) / x); elseif (x <= 7e-7) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 / N[(N[(N[(N[(0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] * (-x)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.8e+168], t$95$0, If[LessEqual[x, -1.85], N[(N[(N[(N[(N[(N[(N[(0.5 / x), $MachinePrecision] + 0.16666666666666666), $MachinePrecision] + N[(0.3333333333333333 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * (-y) + N[(N[(0.5 / x), $MachinePrecision] + 0.5), $MachinePrecision]), $MachinePrecision] * y + -1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7e-7], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-1}{\mathsf{fma}\left(\mathsf{fma}\left(0.5 - \frac{0.5}{x}, y, 1\right), y, 1\right) \cdot \left(-x\right)}\\
\mathbf{if}\;x \leq -7.8 \cdot 10^{+168}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -1.85:\\
\;\;\;\;\frac{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\left(\frac{0.5}{x} + 0.16666666666666666\right) + \frac{0.3333333333333333}{x \cdot x}, -y, \frac{0.5}{x} + 0.5\right), y, -1\right), y, 1\right)}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -7.79999999999999999e168 or 6.99999999999999968e-7 < x Initial program 71.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites71.5%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6479.0
Applied rewrites79.0%
if -7.79999999999999999e168 < x < -1.8500000000000001Initial program 91.5%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites85.1%
if -1.8500000000000001 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
Final simplification86.5%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ -1.0 (* (fma (fma (- 0.5 (/ 0.5 x)) y 1.0) y 1.0) (- x)))))
(if (<= x -7.8e+168)
t_0
(if (<= x -0.64)
(* (fma (fma (- -0.5 (/ 0.5 x)) y 1.0) y -1.0) (/ -1.0 x))
(if (<= x 7e-7) (/ 1.0 x) t_0)))))
double code(double x, double y) {
double t_0 = -1.0 / (fma(fma((0.5 - (0.5 / x)), y, 1.0), y, 1.0) * -x);
double tmp;
if (x <= -7.8e+168) {
tmp = t_0;
} else if (x <= -0.64) {
tmp = fma(fma((-0.5 - (0.5 / x)), y, 1.0), y, -1.0) * (-1.0 / x);
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(fma(fma(Float64(0.5 - Float64(0.5 / x)), y, 1.0), y, 1.0) * Float64(-x))) tmp = 0.0 if (x <= -7.8e+168) tmp = t_0; elseif (x <= -0.64) tmp = Float64(fma(fma(Float64(-0.5 - Float64(0.5 / x)), y, 1.0), y, -1.0) * Float64(-1.0 / x)); elseif (x <= 7e-7) tmp = Float64(1.0 / x); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 / N[(N[(N[(N[(0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] * (-x)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.8e+168], t$95$0, If[LessEqual[x, -0.64], N[(N[(N[(N[(-0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + -1.0), $MachinePrecision] * N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7e-7], N[(1.0 / x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-1}{\mathsf{fma}\left(\mathsf{fma}\left(0.5 - \frac{0.5}{x}, y, 1\right), y, 1\right) \cdot \left(-x\right)}\\
\mathbf{if}\;x \leq -7.8 \cdot 10^{+168}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -0.64:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-0.5 - \frac{0.5}{x}, y, 1\right), y, -1\right) \cdot \frac{-1}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -7.79999999999999999e168 or 6.99999999999999968e-7 < x Initial program 71.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites71.5%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6479.0
Applied rewrites79.0%
if -7.79999999999999999e168 < x < -0.640000000000000013Initial program 91.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
associate-/r/N/A
lower-*.f64N/A
metadata-evalN/A
frac-2negN/A
lower-/.f64N/A
lower-neg.f6491.5
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
lower-pow.f6491.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6491.6
Applied rewrites91.6%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6484.9
Applied rewrites84.9%
if -0.640000000000000013 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
Final simplification86.5%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ -1.0 (- (fma y x x)))))
(if (<= x -7.5e+208)
t_0
(if (<= x -0.64)
(* (fma (fma (- -0.5 (/ 0.5 x)) y 1.0) y -1.0) (/ -1.0 x))
(if (<= x 7e-7) (/ 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.5e+208) {
tmp = t_0;
} else if (x <= -0.64) {
tmp = fma(fma((-0.5 - (0.5 / x)), y, 1.0), y, -1.0) * (-1.0 / x);
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(-fma(y, x, x))) tmp = 0.0 if (x <= -7.5e+208) tmp = t_0; elseif (x <= -0.64) tmp = Float64(fma(fma(Float64(-0.5 - Float64(0.5 / x)), y, 1.0), y, -1.0) * Float64(-1.0 / x)); elseif (x <= 7e-7) 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.5e+208], t$95$0, If[LessEqual[x, -0.64], N[(N[(N[(N[(-0.5 - N[(0.5 / x), $MachinePrecision]), $MachinePrecision] * y + 1.0), $MachinePrecision] * y + -1.0), $MachinePrecision] * N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7e-7], 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.5 \cdot 10^{+208}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -0.64:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-0.5 - \frac{0.5}{x}, y, 1\right), y, -1\right) \cdot \frac{-1}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -7.49999999999999964e208 or 6.99999999999999968e-7 < x Initial program 72.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites72.5%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
mul-1-negN/A
distribute-neg-outN/A
lower-neg.f64N/A
*-commutativeN/A
lower-fma.f6476.5
Applied rewrites76.5%
if -7.49999999999999964e208 < x < -0.640000000000000013Initial program 86.4%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
associate-/r/N/A
lower-*.f64N/A
metadata-evalN/A
frac-2negN/A
lower-/.f64N/A
lower-neg.f6486.4
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
lower-pow.f6486.4
lift-+.f64N/A
+-commutativeN/A
lower-+.f6486.4
Applied rewrites86.4%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-neg-inN/A
metadata-evalN/A
sub-negN/A
lower--.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6481.4
Applied rewrites81.4%
if -0.640000000000000013 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
Final simplification84.9%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ -1.0 (- (fma y x x)))))
(if (<= x -7.5e+208)
t_0
(if (<= x -0.64)
(/ (fma (fma 0.5 y -1.0) y 1.0) x)
(if (<= x 7e-7) (/ 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.5e+208) {
tmp = t_0;
} else if (x <= -0.64) {
tmp = fma(fma(0.5, y, -1.0), y, 1.0) / x;
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(-fma(y, x, x))) tmp = 0.0 if (x <= -7.5e+208) tmp = t_0; elseif (x <= -0.64) tmp = Float64(fma(fma(0.5, y, -1.0), y, 1.0) / x); elseif (x <= 7e-7) 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.5e+208], t$95$0, If[LessEqual[x, -0.64], N[(N[(N[(0.5 * y + -1.0), $MachinePrecision] * y + 1.0), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 7e-7], 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.5 \cdot 10^{+208}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq -0.64:\\
\;\;\;\;\frac{\mathsf{fma}\left(\mathsf{fma}\left(0.5, y, -1\right), y, 1\right)}{x}\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -7.49999999999999964e208 or 6.99999999999999968e-7 < x Initial program 72.5%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites72.5%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
mul-1-negN/A
distribute-neg-outN/A
lower-neg.f64N/A
*-commutativeN/A
lower-fma.f6476.5
Applied rewrites76.5%
if -7.49999999999999964e208 < x < -0.640000000000000013Initial program 86.4%
Taylor expanded in y around 0
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites75.4%
Taylor expanded in x around inf
Applied rewrites81.3%
if -0.640000000000000013 < x < 6.99999999999999968e-7Initial program 78.8%
Taylor expanded in y around 0
Applied rewrites98.1%
(FPCore (x y) :precision binary64 (let* ((t_0 (/ -1.0 (- (fma y x x))))) (if (<= x -1.65e+51) t_0 (if (<= x 7e-7) (/ 1.0 x) t_0))))
double code(double x, double y) {
double t_0 = -1.0 / -fma(y, x, x);
double tmp;
if (x <= -1.65e+51) {
tmp = t_0;
} else if (x <= 7e-7) {
tmp = 1.0 / x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 / Float64(-fma(y, x, x))) tmp = 0.0 if (x <= -1.65e+51) tmp = t_0; elseif (x <= 7e-7) 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, -1.65e+51], t$95$0, If[LessEqual[x, 7e-7], 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 -1.65 \cdot 10^{+51}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 7 \cdot 10^{-7}:\\
\;\;\;\;\frac{1}{x}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -1.6499999999999999e51 or 6.99999999999999968e-7 < x Initial program 74.6%
lift-/.f64N/A
clear-numN/A
frac-2negN/A
metadata-evalN/A
lower-/.f64N/A
div-invN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
pow-flipN/A
neg-mul-1N/A
pow-unpowN/A
Applied rewrites74.6%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
mul-1-negN/A
distribute-neg-outN/A
lower-neg.f64N/A
*-commutativeN/A
lower-fma.f6476.6
Applied rewrites76.6%
if -1.6499999999999999e51 < x < 6.99999999999999968e-7Initial program 82.7%
Taylor expanded in y around 0
Applied rewrites89.2%
(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 77.9%
Taylor expanded in y around 0
Applied rewrites73.0%
(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 2024276
(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))