
(FPCore (alpha beta i) :precision binary64 (let* ((t_0 (+ (+ alpha beta) (* 2.0 i)))) (/ (+ (/ (/ (* (+ alpha beta) (- beta alpha)) t_0) (+ t_0 2.0)) 1.0) 2.0)))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
return (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
t_0 = (alpha + beta) + (2.0d0 * i)
code = (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0d0)) + 1.0d0) / 2.0d0
end function
public static double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
return (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0;
}
def code(alpha, beta, i): t_0 = (alpha + beta) + (2.0 * i) return (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) return Float64(Float64(Float64(Float64(Float64(Float64(alpha + beta) * Float64(beta - alpha)) / t_0) / Float64(t_0 + 2.0)) + 1.0) / 2.0) end
function tmp = code(alpha, beta, i) t_0 = (alpha + beta) + (2.0 * i); tmp = (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 2.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
\frac{\frac{\frac{\left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)}{t_0}}{t_0 + 2} + 1}{2}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (alpha beta i) :precision binary64 (let* ((t_0 (+ (+ alpha beta) (* 2.0 i)))) (/ (+ (/ (/ (* (+ alpha beta) (- beta alpha)) t_0) (+ t_0 2.0)) 1.0) 2.0)))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
return (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
t_0 = (alpha + beta) + (2.0d0 * i)
code = (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0d0)) + 1.0d0) / 2.0d0
end function
public static double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
return (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0;
}
def code(alpha, beta, i): t_0 = (alpha + beta) + (2.0 * i) return (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) return Float64(Float64(Float64(Float64(Float64(Float64(alpha + beta) * Float64(beta - alpha)) / t_0) / Float64(t_0 + 2.0)) + 1.0) / 2.0) end
function tmp = code(alpha, beta, i) t_0 = (alpha + beta) + (2.0 * i); tmp = (((((alpha + beta) * (beta - alpha)) / t_0) / (t_0 + 2.0)) + 1.0) / 2.0; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 2.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
\frac{\frac{\frac{\left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)}{t_0}}{t_0 + 2} + 1}{2}
\end{array}
\end{array}
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) (* 2.0 i))))
(if (<=
(/ (/ (* (+ alpha beta) (- beta alpha)) t_0) (+ 2.0 t_0))
-0.9999998)
(/
(-
(/ (+ 2.0 (* 2.0 i)) alpha)
(+ (* -2.0 (/ i alpha)) (* -2.0 (/ beta alpha))))
2.0)
(/
(log
(exp
(fma
(/ (- beta alpha) (+ (+ alpha beta) (fma 2.0 i 2.0)))
(/ (+ alpha beta) (+ alpha (fma 2.0 i beta)))
1.0)))
2.0))))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
double tmp;
if (((((alpha + beta) * (beta - alpha)) / t_0) / (2.0 + t_0)) <= -0.9999998) {
tmp = (((2.0 + (2.0 * i)) / alpha) - ((-2.0 * (i / alpha)) + (-2.0 * (beta / alpha)))) / 2.0;
} else {
tmp = log(exp(fma(((beta - alpha) / ((alpha + beta) + fma(2.0, i, 2.0))), ((alpha + beta) / (alpha + fma(2.0, i, beta))), 1.0))) / 2.0;
}
return tmp;
}
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) tmp = 0.0 if (Float64(Float64(Float64(Float64(alpha + beta) * Float64(beta - alpha)) / t_0) / Float64(2.0 + t_0)) <= -0.9999998) tmp = Float64(Float64(Float64(Float64(2.0 + Float64(2.0 * i)) / alpha) - Float64(Float64(-2.0 * Float64(i / alpha)) + Float64(-2.0 * Float64(beta / alpha)))) / 2.0); else tmp = Float64(log(exp(fma(Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + fma(2.0, i, 2.0))), Float64(Float64(alpha + beta) / Float64(alpha + fma(2.0, i, beta))), 1.0))) / 2.0); end return tmp end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(2.0 + t$95$0), $MachinePrecision]), $MachinePrecision], -0.9999998], N[(N[(N[(N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] - N[(N[(-2.0 * N[(i / alpha), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(beta / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[Log[N[Exp[N[(N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(alpha + beta), $MachinePrecision] / N[(alpha + N[(2.0 * i + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
\mathbf{if}\;\frac{\frac{\left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)}{t_0}}{2 + t_0} \leq -0.9999998:\\
\;\;\;\;\frac{\frac{2 + 2 \cdot i}{\alpha} - \left(-2 \cdot \frac{i}{\alpha} + -2 \cdot \frac{\beta}{\alpha}\right)}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\log \left(e^{\mathsf{fma}\left(\frac{\beta - \alpha}{\left(\alpha + \beta\right) + \mathsf{fma}\left(2, i, 2\right)}, \frac{\alpha + \beta}{\alpha + \mathsf{fma}\left(2, i, \beta\right)}, 1\right)}\right)}{2}\\
\end{array}
\end{array}
if (/.f64 (/.f64 (*.f64 (+.f64 alpha beta) (-.f64 beta alpha)) (+.f64 (+.f64 alpha beta) (*.f64 2 i))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 2 i)) 2)) < -0.999999799999999994Initial program 3.5%
Simplified18.6%
Taylor expanded in alpha around -inf 85.6%
Taylor expanded in beta around inf 85.8%
if -0.999999799999999994 < (/.f64 (/.f64 (*.f64 (+.f64 alpha beta) (-.f64 beta alpha)) (+.f64 (+.f64 alpha beta) (*.f64 2 i))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 2 i)) 2)) Initial program 83.9%
associate-/l/83.4%
*-commutative83.4%
times-frac99.7%
associate-+l+99.7%
fma-def99.7%
+-commutative99.7%
fma-def99.7%
Simplified99.7%
frac-times83.4%
*-commutative83.4%
fma-def83.4%
fma-udef83.4%
+-commutative83.4%
associate-+r+83.4%
add-log-exp83.4%
Applied egg-rr99.8%
Final simplification96.8%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) (* 2.0 i))))
(if (<=
(/ (/ (* (+ alpha beta) (- beta alpha)) t_0) (+ 2.0 t_0))
-0.9999998)
(/
(-
(/ (+ 2.0 (* 2.0 i)) alpha)
(+ (* -2.0 (/ i alpha)) (* -2.0 (/ beta alpha))))
2.0)
(/
(+
1.0
(*
(/ (- beta alpha) (+ (+ alpha beta) (fma 2.0 i 2.0)))
(/ (+ alpha beta) (fma 2.0 i (+ alpha beta)))))
2.0))))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
double tmp;
if (((((alpha + beta) * (beta - alpha)) / t_0) / (2.0 + t_0)) <= -0.9999998) {
tmp = (((2.0 + (2.0 * i)) / alpha) - ((-2.0 * (i / alpha)) + (-2.0 * (beta / alpha)))) / 2.0;
} else {
tmp = (1.0 + (((beta - alpha) / ((alpha + beta) + fma(2.0, i, 2.0))) * ((alpha + beta) / fma(2.0, i, (alpha + beta))))) / 2.0;
}
return tmp;
}
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) tmp = 0.0 if (Float64(Float64(Float64(Float64(alpha + beta) * Float64(beta - alpha)) / t_0) / Float64(2.0 + t_0)) <= -0.9999998) tmp = Float64(Float64(Float64(Float64(2.0 + Float64(2.0 * i)) / alpha) - Float64(Float64(-2.0 * Float64(i / alpha)) + Float64(-2.0 * Float64(beta / alpha)))) / 2.0); else tmp = Float64(Float64(1.0 + Float64(Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + fma(2.0, i, 2.0))) * Float64(Float64(alpha + beta) / fma(2.0, i, Float64(alpha + beta))))) / 2.0); end return tmp end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(2.0 + t$95$0), $MachinePrecision]), $MachinePrecision], -0.9999998], N[(N[(N[(N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] - N[(N[(-2.0 * N[(i / alpha), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(beta / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(1.0 + N[(N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(alpha + beta), $MachinePrecision] / N[(2.0 * i + N[(alpha + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
\mathbf{if}\;\frac{\frac{\left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)}{t_0}}{2 + t_0} \leq -0.9999998:\\
\;\;\;\;\frac{\frac{2 + 2 \cdot i}{\alpha} - \left(-2 \cdot \frac{i}{\alpha} + -2 \cdot \frac{\beta}{\alpha}\right)}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 + \frac{\beta - \alpha}{\left(\alpha + \beta\right) + \mathsf{fma}\left(2, i, 2\right)} \cdot \frac{\alpha + \beta}{\mathsf{fma}\left(2, i, \alpha + \beta\right)}}{2}\\
\end{array}
\end{array}
if (/.f64 (/.f64 (*.f64 (+.f64 alpha beta) (-.f64 beta alpha)) (+.f64 (+.f64 alpha beta) (*.f64 2 i))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 2 i)) 2)) < -0.999999799999999994Initial program 3.5%
Simplified18.6%
Taylor expanded in alpha around -inf 85.6%
Taylor expanded in beta around inf 85.8%
if -0.999999799999999994 < (/.f64 (/.f64 (*.f64 (+.f64 alpha beta) (-.f64 beta alpha)) (+.f64 (+.f64 alpha beta) (*.f64 2 i))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 2 i)) 2)) Initial program 83.9%
associate-/l/83.4%
*-commutative83.4%
times-frac99.7%
associate-+l+99.7%
fma-def99.7%
+-commutative99.7%
fma-def99.7%
Simplified99.7%
Final simplification96.8%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) (* 2.0 i)))
(t_1 (/ (/ (* (+ alpha beta) (- beta alpha)) t_0) (+ 2.0 t_0))))
(if (<= t_1 -0.9999998)
(/
(-
(/ (+ 2.0 (* 2.0 i)) alpha)
(+ (* -2.0 (/ i alpha)) (* -2.0 (/ beta alpha))))
2.0)
(if (<= t_1 2e-5)
(/ (+ t_1 1.0) 2.0)
(/ (+ 1.0 (/ (- beta alpha) (+ beta (+ alpha 2.0)))) 2.0)))))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
double t_1 = (((alpha + beta) * (beta - alpha)) / t_0) / (2.0 + t_0);
double tmp;
if (t_1 <= -0.9999998) {
tmp = (((2.0 + (2.0 * i)) / alpha) - ((-2.0 * (i / alpha)) + (-2.0 * (beta / alpha)))) / 2.0;
} else if (t_1 <= 2e-5) {
tmp = (t_1 + 1.0) / 2.0;
} else {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (alpha + beta) + (2.0d0 * i)
t_1 = (((alpha + beta) * (beta - alpha)) / t_0) / (2.0d0 + t_0)
if (t_1 <= (-0.9999998d0)) then
tmp = (((2.0d0 + (2.0d0 * i)) / alpha) - (((-2.0d0) * (i / alpha)) + ((-2.0d0) * (beta / alpha)))) / 2.0d0
else if (t_1 <= 2d-5) then
tmp = (t_1 + 1.0d0) / 2.0d0
else
tmp = (1.0d0 + ((beta - alpha) / (beta + (alpha + 2.0d0)))) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
double t_1 = (((alpha + beta) * (beta - alpha)) / t_0) / (2.0 + t_0);
double tmp;
if (t_1 <= -0.9999998) {
tmp = (((2.0 + (2.0 * i)) / alpha) - ((-2.0 * (i / alpha)) + (-2.0 * (beta / alpha)))) / 2.0;
} else if (t_1 <= 2e-5) {
tmp = (t_1 + 1.0) / 2.0;
} else {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = (alpha + beta) + (2.0 * i) t_1 = (((alpha + beta) * (beta - alpha)) / t_0) / (2.0 + t_0) tmp = 0 if t_1 <= -0.9999998: tmp = (((2.0 + (2.0 * i)) / alpha) - ((-2.0 * (i / alpha)) + (-2.0 * (beta / alpha)))) / 2.0 elif t_1 <= 2e-5: tmp = (t_1 + 1.0) / 2.0 else: tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_1 = Float64(Float64(Float64(Float64(alpha + beta) * Float64(beta - alpha)) / t_0) / Float64(2.0 + t_0)) tmp = 0.0 if (t_1 <= -0.9999998) tmp = Float64(Float64(Float64(Float64(2.0 + Float64(2.0 * i)) / alpha) - Float64(Float64(-2.0 * Float64(i / alpha)) + Float64(-2.0 * Float64(beta / alpha)))) / 2.0); elseif (t_1 <= 2e-5) tmp = Float64(Float64(t_1 + 1.0) / 2.0); else tmp = Float64(Float64(1.0 + Float64(Float64(beta - alpha) / Float64(beta + Float64(alpha + 2.0)))) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = (alpha + beta) + (2.0 * i); t_1 = (((alpha + beta) * (beta - alpha)) / t_0) / (2.0 + t_0); tmp = 0.0; if (t_1 <= -0.9999998) tmp = (((2.0 + (2.0 * i)) / alpha) - ((-2.0 * (i / alpha)) + (-2.0 * (beta / alpha)))) / 2.0; elseif (t_1 <= 2e-5) tmp = (t_1 + 1.0) / 2.0; else tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(2.0 + t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -0.9999998], N[(N[(N[(N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] - N[(N[(-2.0 * N[(i / alpha), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(beta / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[t$95$1, 2e-5], N[(N[(t$95$1 + 1.0), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(1.0 + N[(N[(beta - alpha), $MachinePrecision] / N[(beta + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_1 := \frac{\frac{\left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)}{t_0}}{2 + t_0}\\
\mathbf{if}\;t_1 \leq -0.9999998:\\
\;\;\;\;\frac{\frac{2 + 2 \cdot i}{\alpha} - \left(-2 \cdot \frac{i}{\alpha} + -2 \cdot \frac{\beta}{\alpha}\right)}{2}\\
\mathbf{elif}\;t_1 \leq 2 \cdot 10^{-5}:\\
\;\;\;\;\frac{t_1 + 1}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 + \frac{\beta - \alpha}{\beta + \left(\alpha + 2\right)}}{2}\\
\end{array}
\end{array}
if (/.f64 (/.f64 (*.f64 (+.f64 alpha beta) (-.f64 beta alpha)) (+.f64 (+.f64 alpha beta) (*.f64 2 i))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 2 i)) 2)) < -0.999999799999999994Initial program 3.5%
Simplified18.6%
Taylor expanded in alpha around -inf 85.6%
Taylor expanded in beta around inf 85.8%
if -0.999999799999999994 < (/.f64 (/.f64 (*.f64 (+.f64 alpha beta) (-.f64 beta alpha)) (+.f64 (+.f64 alpha beta) (*.f64 2 i))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 2 i)) 2)) < 2.00000000000000016e-5Initial program 99.6%
if 2.00000000000000016e-5 < (/.f64 (/.f64 (*.f64 (+.f64 alpha beta) (-.f64 beta alpha)) (+.f64 (+.f64 alpha beta) (*.f64 2 i))) (+.f64 (+.f64 (+.f64 alpha beta) (*.f64 2 i)) 2)) Initial program 39.7%
associate-/l/37.7%
*-commutative37.7%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 98.5%
+-commutative98.5%
Simplified98.5%
Final simplification96.4%
(FPCore (alpha beta i)
:precision binary64
(if (<= alpha 5e-57)
(/ (+ 1.0 (/ (- beta alpha) (+ beta (+ alpha 2.0)))) 2.0)
(if (<= alpha 5.2e+24)
(/
(-
1.0
(/ (* alpha alpha) (* (+ alpha (* 2.0 i)) (+ (* 2.0 i) (+ alpha 2.0)))))
2.0)
(if (<= alpha 9.5e+98)
(/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)
(/ (/ (+ beta (+ beta (+ 2.0 (* i 4.0)))) alpha) 2.0)))))
double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 5e-57) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 5.2e+24) {
tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0;
} else if (alpha <= 9.5e+98) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (alpha <= 5d-57) then
tmp = (1.0d0 + ((beta - alpha) / (beta + (alpha + 2.0d0)))) / 2.0d0
else if (alpha <= 5.2d+24) then
tmp = (1.0d0 - ((alpha * alpha) / ((alpha + (2.0d0 * i)) * ((2.0d0 * i) + (alpha + 2.0d0))))) / 2.0d0
else if (alpha <= 9.5d+98) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = ((beta + (beta + (2.0d0 + (i * 4.0d0)))) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 5e-57) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 5.2e+24) {
tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0;
} else if (alpha <= 9.5e+98) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if alpha <= 5e-57: tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0 elif alpha <= 5.2e+24: tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0 elif alpha <= 9.5e+98: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (alpha <= 5e-57) tmp = Float64(Float64(1.0 + Float64(Float64(beta - alpha) / Float64(beta + Float64(alpha + 2.0)))) / 2.0); elseif (alpha <= 5.2e+24) tmp = Float64(Float64(1.0 - Float64(Float64(alpha * alpha) / Float64(Float64(alpha + Float64(2.0 * i)) * Float64(Float64(2.0 * i) + Float64(alpha + 2.0))))) / 2.0); elseif (alpha <= 9.5e+98) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = Float64(Float64(Float64(beta + Float64(beta + Float64(2.0 + Float64(i * 4.0)))) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (alpha <= 5e-57) tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0; elseif (alpha <= 5.2e+24) tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0; elseif (alpha <= 9.5e+98) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[alpha, 5e-57], N[(N[(1.0 + N[(N[(beta - alpha), $MachinePrecision] / N[(beta + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 5.2e+24], N[(N[(1.0 - N[(N[(alpha * alpha), $MachinePrecision] / N[(N[(alpha + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 * i), $MachinePrecision] + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 9.5e+98], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(beta + N[(beta + N[(2.0 + N[(i * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 5 \cdot 10^{-57}:\\
\;\;\;\;\frac{1 + \frac{\beta - \alpha}{\beta + \left(\alpha + 2\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 5.2 \cdot 10^{+24}:\\
\;\;\;\;\frac{1 - \frac{\alpha \cdot \alpha}{\left(\alpha + 2 \cdot i\right) \cdot \left(2 \cdot i + \left(\alpha + 2\right)\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 9.5 \cdot 10^{+98}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\beta + \left(\beta + \left(2 + i \cdot 4\right)\right)}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 5.0000000000000002e-57Initial program 84.8%
associate-/l/84.3%
*-commutative84.3%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 94.9%
+-commutative94.9%
Simplified94.9%
if 5.0000000000000002e-57 < alpha < 5.1999999999999997e24Initial program 91.6%
associate-/l/91.4%
*-commutative91.4%
times-frac95.5%
associate-+l+95.5%
fma-def95.5%
+-commutative95.5%
fma-def95.5%
Simplified95.5%
Taylor expanded in beta around 0 95.4%
associate-*r/95.4%
mul-1-neg95.4%
unpow295.4%
associate-+r+95.4%
+-commutative95.4%
Simplified95.4%
if 5.1999999999999997e24 < alpha < 9.5000000000000001e98Initial program 30.8%
associate-/l/29.4%
*-commutative29.4%
times-frac69.6%
associate-+l+69.6%
fma-def69.6%
+-commutative69.6%
fma-def69.6%
Simplified69.6%
frac-times29.4%
*-commutative29.4%
fma-def29.4%
fma-udef29.4%
+-commutative29.4%
associate-+r+29.4%
add-log-exp29.4%
Applied egg-rr70.2%
Taylor expanded in i around 0 52.4%
associate--l+52.4%
div-sub52.4%
+-commutative52.4%
Simplified52.4%
Taylor expanded in alpha around 0 55.3%
if 9.5000000000000001e98 < alpha Initial program 8.2%
Taylor expanded in alpha around inf 5.2%
Taylor expanded in alpha around -inf 77.7%
Final simplification89.7%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (/ (/ (+ 2.0 (* i 4.0)) alpha) 2.0))
(t_1 (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)))
(if (<= alpha 2.9e-53)
(/ (+ 1.0 (/ (- beta alpha) (+ beta (+ alpha 2.0)))) 2.0)
(if (<= alpha 1.7e+30)
(/ (- 1.0 (/ alpha (+ 2.0 (+ (+ alpha beta) (* 2.0 i))))) 2.0)
(if (<= alpha 6.8e+96)
t_1
(if (<= alpha 1.6e+118)
t_0
(if (<= alpha 1.35e+137)
t_1
(if (<= alpha 1e+227)
(/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0)
t_0))))))))
double code(double alpha, double beta, double i) {
double t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0;
double t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0;
double tmp;
if (alpha <= 2.9e-53) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 1.7e+30) {
tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 6.8e+96) {
tmp = t_1;
} else if (alpha <= 1.6e+118) {
tmp = t_0;
} else if (alpha <= 1.35e+137) {
tmp = t_1;
} else if (alpha <= 1e+227) {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ((2.0d0 + (i * 4.0d0)) / alpha) / 2.0d0
t_1 = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
if (alpha <= 2.9d-53) then
tmp = (1.0d0 + ((beta - alpha) / (beta + (alpha + 2.0d0)))) / 2.0d0
else if (alpha <= 1.7d+30) then
tmp = (1.0d0 - (alpha / (2.0d0 + ((alpha + beta) + (2.0d0 * i))))) / 2.0d0
else if (alpha <= 6.8d+96) then
tmp = t_1
else if (alpha <= 1.6d+118) then
tmp = t_0
else if (alpha <= 1.35d+137) then
tmp = t_1
else if (alpha <= 1d+227) then
tmp = ((2.0d0 + (beta * 2.0d0)) / alpha) / 2.0d0
else
tmp = t_0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0;
double t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0;
double tmp;
if (alpha <= 2.9e-53) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 1.7e+30) {
tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 6.8e+96) {
tmp = t_1;
} else if (alpha <= 1.6e+118) {
tmp = t_0;
} else if (alpha <= 1.35e+137) {
tmp = t_1;
} else if (alpha <= 1e+227) {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0 t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0 tmp = 0 if alpha <= 2.9e-53: tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0 elif alpha <= 1.7e+30: tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0 elif alpha <= 6.8e+96: tmp = t_1 elif alpha <= 1.6e+118: tmp = t_0 elif alpha <= 1.35e+137: tmp = t_1 elif alpha <= 1e+227: tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0 else: tmp = t_0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(Float64(2.0 + Float64(i * 4.0)) / alpha) / 2.0) t_1 = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0) tmp = 0.0 if (alpha <= 2.9e-53) tmp = Float64(Float64(1.0 + Float64(Float64(beta - alpha) / Float64(beta + Float64(alpha + 2.0)))) / 2.0); elseif (alpha <= 1.7e+30) tmp = Float64(Float64(1.0 - Float64(alpha / Float64(2.0 + Float64(Float64(alpha + beta) + Float64(2.0 * i))))) / 2.0); elseif (alpha <= 6.8e+96) tmp = t_1; elseif (alpha <= 1.6e+118) tmp = t_0; elseif (alpha <= 1.35e+137) tmp = t_1; elseif (alpha <= 1e+227) tmp = Float64(Float64(Float64(2.0 + Float64(beta * 2.0)) / alpha) / 2.0); else tmp = t_0; end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0; t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0; tmp = 0.0; if (alpha <= 2.9e-53) tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0; elseif (alpha <= 1.7e+30) tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0; elseif (alpha <= 6.8e+96) tmp = t_1; elseif (alpha <= 1.6e+118) tmp = t_0; elseif (alpha <= 1.35e+137) tmp = t_1; elseif (alpha <= 1e+227) tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0; else tmp = t_0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(N[(2.0 + N[(i * 4.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]}, If[LessEqual[alpha, 2.9e-53], N[(N[(1.0 + N[(N[(beta - alpha), $MachinePrecision] / N[(beta + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 1.7e+30], N[(N[(1.0 - N[(alpha / N[(2.0 + N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 6.8e+96], t$95$1, If[LessEqual[alpha, 1.6e+118], t$95$0, If[LessEqual[alpha, 1.35e+137], t$95$1, If[LessEqual[alpha, 1e+227], N[(N[(N[(2.0 + N[(beta * 2.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], t$95$0]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{2 + i \cdot 4}{\alpha}}{2}\\
t_1 := \frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{if}\;\alpha \leq 2.9 \cdot 10^{-53}:\\
\;\;\;\;\frac{1 + \frac{\beta - \alpha}{\beta + \left(\alpha + 2\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 1.7 \cdot 10^{+30}:\\
\;\;\;\;\frac{1 - \frac{\alpha}{2 + \left(\left(\alpha + \beta\right) + 2 \cdot i\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 6.8 \cdot 10^{+96}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\alpha \leq 1.6 \cdot 10^{+118}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\alpha \leq 1.35 \cdot 10^{+137}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\alpha \leq 10^{+227}:\\
\;\;\;\;\frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if alpha < 2.8999999999999998e-53Initial program 84.8%
associate-/l/84.3%
*-commutative84.3%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 94.9%
+-commutative94.9%
Simplified94.9%
if 2.8999999999999998e-53 < alpha < 1.7000000000000001e30Initial program 91.3%
Taylor expanded in alpha around inf 91.5%
mul-1-neg91.5%
Simplified91.5%
if 1.7000000000000001e30 < alpha < 6.8000000000000002e96 or 1.60000000000000008e118 < alpha < 1.35000000000000009e137Initial program 33.3%
associate-/l/32.1%
*-commutative32.1%
times-frac72.5%
associate-+l+72.5%
fma-def72.5%
+-commutative72.5%
fma-def72.5%
Simplified72.5%
frac-times32.1%
*-commutative32.1%
fma-def32.1%
fma-udef32.1%
+-commutative32.1%
associate-+r+32.1%
add-log-exp32.1%
Applied egg-rr72.1%
Taylor expanded in i around 0 43.0%
associate--l+43.0%
div-sub43.0%
+-commutative43.0%
Simplified43.0%
Taylor expanded in alpha around 0 63.9%
if 6.8000000000000002e96 < alpha < 1.60000000000000008e118 or 1.0000000000000001e227 < alpha Initial program 5.5%
associate-/l/4.7%
*-commutative4.7%
times-frac16.2%
associate-+l+16.2%
fma-def16.2%
+-commutative16.2%
fma-def16.2%
Simplified16.2%
Taylor expanded in beta around 0 4.7%
associate-*r/4.7%
mul-1-neg4.7%
unpow24.7%
associate-+r+4.7%
+-commutative4.7%
Simplified4.7%
Taylor expanded in alpha around inf 89.8%
if 1.35000000000000009e137 < alpha < 1.0000000000000001e227Initial program 1.2%
associate-/l/0.4%
*-commutative0.4%
times-frac31.0%
associate-+l+31.0%
fma-def31.0%
+-commutative31.0%
fma-def31.0%
Simplified31.0%
frac-times0.4%
*-commutative0.4%
fma-def0.4%
fma-udef0.4%
+-commutative0.4%
associate-+r+0.4%
add-log-exp0.4%
Applied egg-rr31.0%
Taylor expanded in i around 0 6.7%
associate--l+6.7%
div-sub6.7%
+-commutative6.7%
Simplified6.7%
Taylor expanded in alpha around inf 59.7%
Final simplification89.2%
(FPCore (alpha beta i)
:precision binary64
(if (<= alpha 4.5e-53)
(/ (+ 1.0 (/ (- beta alpha) (+ beta (+ alpha 2.0)))) 2.0)
(if (<= alpha 1.7e+30)
(/ (- 1.0 (/ alpha (+ 2.0 (+ (+ alpha beta) (* 2.0 i))))) 2.0)
(if (<= alpha 8.5e+97)
(/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)
(/ (/ (+ beta (+ beta (+ 2.0 (* i 4.0)))) alpha) 2.0)))))
double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 4.5e-53) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 1.7e+30) {
tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 8.5e+97) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (alpha <= 4.5d-53) then
tmp = (1.0d0 + ((beta - alpha) / (beta + (alpha + 2.0d0)))) / 2.0d0
else if (alpha <= 1.7d+30) then
tmp = (1.0d0 - (alpha / (2.0d0 + ((alpha + beta) + (2.0d0 * i))))) / 2.0d0
else if (alpha <= 8.5d+97) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = ((beta + (beta + (2.0d0 + (i * 4.0d0)))) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 4.5e-53) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 1.7e+30) {
tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 8.5e+97) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if alpha <= 4.5e-53: tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0 elif alpha <= 1.7e+30: tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0 elif alpha <= 8.5e+97: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (alpha <= 4.5e-53) tmp = Float64(Float64(1.0 + Float64(Float64(beta - alpha) / Float64(beta + Float64(alpha + 2.0)))) / 2.0); elseif (alpha <= 1.7e+30) tmp = Float64(Float64(1.0 - Float64(alpha / Float64(2.0 + Float64(Float64(alpha + beta) + Float64(2.0 * i))))) / 2.0); elseif (alpha <= 8.5e+97) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = Float64(Float64(Float64(beta + Float64(beta + Float64(2.0 + Float64(i * 4.0)))) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (alpha <= 4.5e-53) tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0; elseif (alpha <= 1.7e+30) tmp = (1.0 - (alpha / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0; elseif (alpha <= 8.5e+97) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = ((beta + (beta + (2.0 + (i * 4.0)))) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[alpha, 4.5e-53], N[(N[(1.0 + N[(N[(beta - alpha), $MachinePrecision] / N[(beta + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 1.7e+30], N[(N[(1.0 - N[(alpha / N[(2.0 + N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 8.5e+97], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(beta + N[(beta + N[(2.0 + N[(i * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 4.5 \cdot 10^{-53}:\\
\;\;\;\;\frac{1 + \frac{\beta - \alpha}{\beta + \left(\alpha + 2\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 1.7 \cdot 10^{+30}:\\
\;\;\;\;\frac{1 - \frac{\alpha}{2 + \left(\left(\alpha + \beta\right) + 2 \cdot i\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 8.5 \cdot 10^{+97}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\beta + \left(\beta + \left(2 + i \cdot 4\right)\right)}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 4.49999999999999985e-53Initial program 84.8%
associate-/l/84.3%
*-commutative84.3%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 94.9%
+-commutative94.9%
Simplified94.9%
if 4.49999999999999985e-53 < alpha < 1.7000000000000001e30Initial program 91.3%
Taylor expanded in alpha around inf 91.5%
mul-1-neg91.5%
Simplified91.5%
if 1.7000000000000001e30 < alpha < 8.4999999999999993e97Initial program 24.8%
associate-/l/23.4%
*-commutative23.4%
times-frac67.9%
associate-+l+67.9%
fma-def67.9%
+-commutative67.9%
fma-def67.9%
Simplified67.9%
frac-times23.4%
*-commutative23.4%
fma-def23.4%
fma-udef23.4%
+-commutative23.4%
associate-+r+23.4%
add-log-exp23.4%
Applied egg-rr67.9%
Taylor expanded in i around 0 48.1%
associate--l+48.1%
div-sub48.1%
+-commutative48.1%
Simplified48.1%
Taylor expanded in alpha around 0 59.9%
if 8.4999999999999993e97 < alpha Initial program 8.2%
Taylor expanded in alpha around inf 5.2%
Taylor expanded in alpha around -inf 77.7%
Final simplification89.6%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (/ (/ (+ 2.0 (* i 4.0)) alpha) 2.0))
(t_1 (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)))
(if (<= alpha 3.2e+97)
t_1
(if (<= alpha 1.65e+118)
t_0
(if (<= alpha 4.4e+140)
t_1
(if (<= alpha 4.8e+226)
(/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0)
t_0))))))
double code(double alpha, double beta, double i) {
double t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0;
double t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0;
double tmp;
if (alpha <= 3.2e+97) {
tmp = t_1;
} else if (alpha <= 1.65e+118) {
tmp = t_0;
} else if (alpha <= 4.4e+140) {
tmp = t_1;
} else if (alpha <= 4.8e+226) {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = ((2.0d0 + (i * 4.0d0)) / alpha) / 2.0d0
t_1 = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
if (alpha <= 3.2d+97) then
tmp = t_1
else if (alpha <= 1.65d+118) then
tmp = t_0
else if (alpha <= 4.4d+140) then
tmp = t_1
else if (alpha <= 4.8d+226) then
tmp = ((2.0d0 + (beta * 2.0d0)) / alpha) / 2.0d0
else
tmp = t_0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0;
double t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0;
double tmp;
if (alpha <= 3.2e+97) {
tmp = t_1;
} else if (alpha <= 1.65e+118) {
tmp = t_0;
} else if (alpha <= 4.4e+140) {
tmp = t_1;
} else if (alpha <= 4.8e+226) {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0 t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0 tmp = 0 if alpha <= 3.2e+97: tmp = t_1 elif alpha <= 1.65e+118: tmp = t_0 elif alpha <= 4.4e+140: tmp = t_1 elif alpha <= 4.8e+226: tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0 else: tmp = t_0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(Float64(2.0 + Float64(i * 4.0)) / alpha) / 2.0) t_1 = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0) tmp = 0.0 if (alpha <= 3.2e+97) tmp = t_1; elseif (alpha <= 1.65e+118) tmp = t_0; elseif (alpha <= 4.4e+140) tmp = t_1; elseif (alpha <= 4.8e+226) tmp = Float64(Float64(Float64(2.0 + Float64(beta * 2.0)) / alpha) / 2.0); else tmp = t_0; end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = ((2.0 + (i * 4.0)) / alpha) / 2.0; t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0; tmp = 0.0; if (alpha <= 3.2e+97) tmp = t_1; elseif (alpha <= 1.65e+118) tmp = t_0; elseif (alpha <= 4.4e+140) tmp = t_1; elseif (alpha <= 4.8e+226) tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0; else tmp = t_0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(N[(2.0 + N[(i * 4.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]}, If[LessEqual[alpha, 3.2e+97], t$95$1, If[LessEqual[alpha, 1.65e+118], t$95$0, If[LessEqual[alpha, 4.4e+140], t$95$1, If[LessEqual[alpha, 4.8e+226], N[(N[(N[(2.0 + N[(beta * 2.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], t$95$0]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{2 + i \cdot 4}{\alpha}}{2}\\
t_1 := \frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{if}\;\alpha \leq 3.2 \cdot 10^{+97}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\alpha \leq 1.65 \cdot 10^{+118}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\alpha \leq 4.4 \cdot 10^{+140}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\alpha \leq 4.8 \cdot 10^{+226}:\\
\;\;\;\;\frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if alpha < 3.20000000000000016e97 or 1.65e118 < alpha < 4.3999999999999997e140Initial program 81.9%
associate-/l/81.4%
*-commutative81.4%
times-frac97.4%
associate-+l+97.4%
fma-def97.4%
+-commutative97.4%
fma-def97.4%
Simplified97.4%
frac-times81.4%
*-commutative81.4%
fma-def81.4%
fma-udef81.4%
+-commutative81.4%
associate-+r+81.4%
add-log-exp81.4%
Applied egg-rr97.4%
Taylor expanded in i around 0 88.1%
associate--l+88.1%
div-sub88.1%
+-commutative88.1%
Simplified88.1%
Taylor expanded in alpha around 0 89.9%
if 3.20000000000000016e97 < alpha < 1.65e118 or 4.8e226 < alpha Initial program 5.5%
associate-/l/4.7%
*-commutative4.7%
times-frac16.2%
associate-+l+16.2%
fma-def16.2%
+-commutative16.2%
fma-def16.2%
Simplified16.2%
Taylor expanded in beta around 0 4.7%
associate-*r/4.7%
mul-1-neg4.7%
unpow24.7%
associate-+r+4.7%
+-commutative4.7%
Simplified4.7%
Taylor expanded in alpha around inf 89.8%
if 4.3999999999999997e140 < alpha < 4.8e226Initial program 1.2%
associate-/l/0.4%
*-commutative0.4%
times-frac31.0%
associate-+l+31.0%
fma-def31.0%
+-commutative31.0%
fma-def31.0%
Simplified31.0%
frac-times0.4%
*-commutative0.4%
fma-def0.4%
fma-udef0.4%
+-commutative0.4%
associate-+r+0.4%
add-log-exp0.4%
Applied egg-rr31.0%
Taylor expanded in i around 0 6.7%
associate--l+6.7%
div-sub6.7%
+-commutative6.7%
Simplified6.7%
Taylor expanded in alpha around inf 59.7%
Final simplification87.3%
(FPCore (alpha beta i) :precision binary64 (if (<= alpha 2.05e+161) (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0) (/ (/ (- (* i -4.0)) alpha) 2.0)))
double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 2.05e+161) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (-(i * -4.0) / alpha) / 2.0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (alpha <= 2.05d+161) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = (-(i * (-4.0d0)) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 2.05e+161) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (-(i * -4.0) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if alpha <= 2.05e+161: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = (-(i * -4.0) / alpha) / 2.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (alpha <= 2.05e+161) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = Float64(Float64(Float64(-Float64(i * -4.0)) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (alpha <= 2.05e+161) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = (-(i * -4.0) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[alpha, 2.05e+161], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[((-N[(i * -4.0), $MachinePrecision]) / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 2.05 \cdot 10^{+161}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{-i \cdot -4}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 2.0500000000000001e161Initial program 77.7%
associate-/l/77.2%
*-commutative77.2%
times-frac93.2%
associate-+l+93.2%
fma-def93.2%
+-commutative93.2%
fma-def93.2%
Simplified93.2%
frac-times77.2%
*-commutative77.2%
fma-def77.2%
fma-udef77.2%
+-commutative77.2%
associate-+r+77.2%
add-log-exp77.2%
Applied egg-rr93.2%
Taylor expanded in i around 0 83.1%
associate--l+83.1%
div-sub83.1%
+-commutative83.1%
Simplified83.1%
Taylor expanded in alpha around 0 86.1%
if 2.0500000000000001e161 < alpha Initial program 1.0%
Simplified18.5%
Taylor expanded in alpha around -inf 85.0%
Taylor expanded in i around inf 42.4%
*-commutative42.4%
Simplified42.4%
Final simplification79.9%
(FPCore (alpha beta i) :precision binary64 (if (<= alpha 1e+98) (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0) (/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0)))
double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 1e+98) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (alpha <= 1d+98) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = ((2.0d0 + (beta * 2.0d0)) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 1e+98) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if alpha <= 1e+98: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (alpha <= 1e+98) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = Float64(Float64(Float64(2.0 + Float64(beta * 2.0)) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (alpha <= 1e+98) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[alpha, 1e+98], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(2.0 + N[(beta * 2.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 10^{+98}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 9.99999999999999998e97Initial program 83.0%
associate-/l/82.5%
*-commutative82.5%
times-frac97.9%
associate-+l+97.9%
fma-def97.9%
+-commutative97.9%
fma-def97.9%
Simplified97.9%
frac-times82.5%
*-commutative82.5%
fma-def82.5%
fma-udef82.5%
+-commutative82.5%
associate-+r+82.5%
add-log-exp82.5%
Applied egg-rr98.0%
Taylor expanded in i around 0 89.7%
associate--l+89.7%
div-sub89.7%
+-commutative89.7%
Simplified89.7%
Taylor expanded in alpha around 0 90.5%
if 9.99999999999999998e97 < alpha Initial program 8.2%
associate-/l/7.4%
*-commutative7.4%
times-frac29.0%
associate-+l+29.0%
fma-def29.0%
+-commutative29.0%
fma-def29.0%
Simplified29.0%
frac-times7.4%
*-commutative7.4%
fma-def7.4%
fma-udef7.4%
+-commutative7.4%
associate-+r+7.4%
add-log-exp7.4%
Applied egg-rr28.9%
Taylor expanded in i around 0 9.2%
associate--l+9.2%
div-sub9.2%
+-commutative9.2%
Simplified9.2%
Taylor expanded in alpha around inf 48.2%
Final simplification81.4%
(FPCore (alpha beta i) :precision binary64 (if (<= beta 1.95e+68) 0.5 1.0))
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 1.95e+68) {
tmp = 0.5;
} else {
tmp = 1.0;
}
return tmp;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 1.95d+68) then
tmp = 0.5d0
else
tmp = 1.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 1.95e+68) {
tmp = 0.5;
} else {
tmp = 1.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if beta <= 1.95e+68: tmp = 0.5 else: tmp = 1.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (beta <= 1.95e+68) tmp = 0.5; else tmp = 1.0; end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (beta <= 1.95e+68) tmp = 0.5; else tmp = 1.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[beta, 1.95e+68], 0.5, 1.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.95 \cdot 10^{+68}:\\
\;\;\;\;0.5\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if beta < 1.95000000000000009e68Initial program 77.5%
associate-/l/77.3%
*-commutative77.3%
times-frac81.4%
associate-+l+81.4%
fma-def81.4%
+-commutative81.4%
fma-def81.4%
Simplified81.4%
Taylor expanded in i around inf 76.9%
if 1.95000000000000009e68 < beta Initial program 30.0%
associate-/l/28.1%
*-commutative28.1%
times-frac89.2%
associate-+l+89.2%
fma-def89.2%
+-commutative89.2%
fma-def89.2%
Simplified89.2%
Taylor expanded in beta around inf 83.0%
Final simplification78.2%
(FPCore (alpha beta i) :precision binary64 0.5)
double code(double alpha, double beta, double i) {
return 0.5;
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
code = 0.5d0
end function
public static double code(double alpha, double beta, double i) {
return 0.5;
}
def code(alpha, beta, i): return 0.5
function code(alpha, beta, i) return 0.5 end
function tmp = code(alpha, beta, i) tmp = 0.5; end
code[alpha_, beta_, i_] := 0.5
\begin{array}{l}
\\
0.5
\end{array}
Initial program 66.9%
associate-/l/66.4%
*-commutative66.4%
times-frac83.1%
associate-+l+83.1%
fma-def83.1%
+-commutative83.1%
fma-def83.1%
Simplified83.1%
Taylor expanded in i around inf 64.7%
Final simplification64.7%
herbie shell --seed 2023240
(FPCore (alpha beta i)
:name "Octave 3.8, jcobi/2"
:precision binary64
:pre (and (and (> alpha -1.0) (> beta -1.0)) (> i 0.0))
(/ (+ (/ (/ (* (+ alpha beta) (- beta alpha)) (+ (+ alpha beta) (* 2.0 i))) (+ (+ (+ alpha beta) (* 2.0 i)) 2.0)) 1.0) 2.0))