
(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 14 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.999999995)
(/ (/ (+ (+ beta (* 2.0 i)) (+ beta (+ 2.0 (* 2.0 i)))) alpha) 2.0)
(/
(fma
(/ (- beta alpha) (+ (+ alpha beta) (fma 2.0 i 2.0)))
(/ 1.0 (/ (+ alpha (fma 2.0 i beta)) (+ alpha 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.999999995) {
tmp = (((beta + (2.0 * i)) + (beta + (2.0 + (2.0 * i)))) / alpha) / 2.0;
} else {
tmp = fma(((beta - alpha) / ((alpha + beta) + fma(2.0, i, 2.0))), (1.0 / ((alpha + fma(2.0, i, beta)) / (alpha + 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.999999995) tmp = Float64(Float64(Float64(Float64(beta + Float64(2.0 * i)) + Float64(beta + Float64(2.0 + Float64(2.0 * i)))) / alpha) / 2.0); else tmp = Float64(fma(Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + fma(2.0, i, 2.0))), Float64(1.0 / Float64(Float64(alpha + fma(2.0, i, beta)) / Float64(alpha + 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.999999995], N[(N[(N[(N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] + N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(alpha + N[(2.0 * i + beta), $MachinePrecision]), $MachinePrecision] / N[(alpha + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $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.999999995:\\
\;\;\;\;\frac{\frac{\left(\beta + 2 \cdot i\right) + \left(\beta + \left(2 + 2 \cdot i\right)\right)}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{\beta - \alpha}{\left(\alpha + \beta\right) + \mathsf{fma}\left(2, i, 2\right)}, \frac{1}{\frac{\alpha + \mathsf{fma}\left(2, i, \beta\right)}{\alpha + \beta}}, 1\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.99999999500000003Initial program 4.8%
associate-/l/4.0%
*-commutative4.0%
times-frac15.6%
fma-def15.6%
associate-+l+15.6%
fma-def15.6%
associate-+l+15.6%
+-commutative15.6%
fma-def15.6%
Simplified15.6%
Taylor expanded in alpha around inf 91.6%
if -0.99999999500000003 < (/.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 84.5%
associate-/l/84.1%
*-commutative84.1%
times-frac99.3%
fma-def99.4%
associate-+l+99.4%
fma-def99.4%
associate-+l+99.4%
+-commutative99.4%
fma-def99.4%
Simplified99.4%
clear-num99.4%
inv-pow99.4%
+-commutative99.4%
Applied egg-rr99.4%
unpow-199.4%
+-commutative99.4%
Simplified99.4%
Final simplification97.5%
(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.999999995)
(/ (/ (+ (+ beta (* 2.0 i)) (+ beta (+ 2.0 (* 2.0 i)))) alpha) 2.0)
(/
(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.999999995) {
tmp = (((beta + (2.0 * i)) + (beta + (2.0 + (2.0 * i)))) / alpha) / 2.0;
} else {
tmp = 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.999999995) tmp = Float64(Float64(Float64(Float64(beta + Float64(2.0 * i)) + Float64(beta + Float64(2.0 + Float64(2.0 * i)))) / alpha) / 2.0); else tmp = Float64(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.999999995], N[(N[(N[(N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] + N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], N[(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] / 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.999999995:\\
\;\;\;\;\frac{\frac{\left(\beta + 2 \cdot i\right) + \left(\beta + \left(2 + 2 \cdot i\right)\right)}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\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)}{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.99999999500000003Initial program 4.8%
associate-/l/4.0%
*-commutative4.0%
times-frac15.6%
fma-def15.6%
associate-+l+15.6%
fma-def15.6%
associate-+l+15.6%
+-commutative15.6%
fma-def15.6%
Simplified15.6%
Taylor expanded in alpha around inf 91.6%
if -0.99999999500000003 < (/.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 84.5%
associate-/l/84.1%
*-commutative84.1%
times-frac99.3%
fma-def99.4%
associate-+l+99.4%
fma-def99.4%
associate-+l+99.4%
+-commutative99.4%
fma-def99.4%
Simplified99.4%
Final simplification97.5%
(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.999999995)
(/ (/ (+ (+ beta (* 2.0 i)) (+ beta (+ 2.0 (* 2.0 i)))) 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.999999995) {
tmp = (((beta + (2.0 * i)) + (beta + (2.0 + (2.0 * i)))) / 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.999999995) tmp = Float64(Float64(Float64(Float64(beta + Float64(2.0 * i)) + Float64(beta + Float64(2.0 + Float64(2.0 * i)))) / 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.999999995], N[(N[(N[(N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] + N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $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.999999995:\\
\;\;\;\;\frac{\frac{\left(\beta + 2 \cdot i\right) + \left(\beta + \left(2 + 2 \cdot i\right)\right)}{\alpha}}{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.99999999500000003Initial program 4.8%
associate-/l/4.0%
*-commutative4.0%
times-frac15.6%
fma-def15.6%
associate-+l+15.6%
fma-def15.6%
associate-+l+15.6%
+-commutative15.6%
fma-def15.6%
Simplified15.6%
Taylor expanded in alpha around inf 91.6%
if -0.99999999500000003 < (/.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 84.5%
associate-/l/84.1%
*-commutative84.1%
times-frac99.3%
associate-+l+99.3%
fma-def99.3%
+-commutative99.3%
fma-def99.3%
Simplified99.3%
Final simplification97.5%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ beta (* 2.0 i))) (t_1 (+ (+ alpha beta) (* 2.0 i))))
(if (<= (/ (/ (* (+ alpha beta) (- beta alpha)) t_1) (+ 2.0 t_1)) -0.8)
(/ (/ (+ t_0 (+ beta (+ 2.0 (* 2.0 i)))) alpha) 2.0)
(/
(fma
(/ (- beta alpha) (+ (+ alpha beta) (fma 2.0 i 2.0)))
(/ 1.0 (/ t_0 beta))
1.0)
2.0))))
double code(double alpha, double beta, double i) {
double t_0 = beta + (2.0 * i);
double t_1 = (alpha + beta) + (2.0 * i);
double tmp;
if (((((alpha + beta) * (beta - alpha)) / t_1) / (2.0 + t_1)) <= -0.8) {
tmp = ((t_0 + (beta + (2.0 + (2.0 * i)))) / alpha) / 2.0;
} else {
tmp = fma(((beta - alpha) / ((alpha + beta) + fma(2.0, i, 2.0))), (1.0 / (t_0 / beta)), 1.0) / 2.0;
}
return tmp;
}
function code(alpha, beta, i) t_0 = Float64(beta + Float64(2.0 * i)) t_1 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) tmp = 0.0 if (Float64(Float64(Float64(Float64(alpha + beta) * Float64(beta - alpha)) / t_1) / Float64(2.0 + t_1)) <= -0.8) tmp = Float64(Float64(Float64(t_0 + Float64(beta + Float64(2.0 + Float64(2.0 * i)))) / alpha) / 2.0); else tmp = Float64(fma(Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + fma(2.0, i, 2.0))), Float64(1.0 / Float64(t_0 / beta)), 1.0) / 2.0); end return tmp end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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$1), $MachinePrecision] / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision], -0.8], N[(N[(N[(t$95$0 + N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(t$95$0 / beta), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \beta + 2 \cdot i\\
t_1 := \left(\alpha + \beta\right) + 2 \cdot i\\
\mathbf{if}\;\frac{\frac{\left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)}{t_1}}{2 + t_1} \leq -0.8:\\
\;\;\;\;\frac{\frac{t_0 + \left(\beta + \left(2 + 2 \cdot i\right)\right)}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{\beta - \alpha}{\left(\alpha + \beta\right) + \mathsf{fma}\left(2, i, 2\right)}, \frac{1}{\frac{t_0}{\beta}}, 1\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.80000000000000004Initial program 8.8%
associate-/l/8.1%
*-commutative8.1%
times-frac18.9%
fma-def19.0%
associate-+l+19.0%
fma-def19.0%
associate-+l+19.0%
+-commutative19.0%
fma-def19.0%
Simplified19.0%
Taylor expanded in alpha around inf 89.2%
if -0.80000000000000004 < (/.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 84.8%
associate-/l/84.4%
*-commutative84.4%
times-frac100.0%
fma-def100.0%
associate-+l+100.0%
fma-def100.0%
associate-+l+100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
clear-num100.0%
inv-pow100.0%
+-commutative100.0%
Applied egg-rr100.0%
unpow-1100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in alpha around 0 98.9%
Final simplification96.4%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) (* 2.0 i)))
(t_1 (+ beta (* 2.0 i)))
(t_2 (* (+ alpha beta) (- beta alpha)))
(t_3 (/ (/ t_2 t_0) (+ 2.0 t_0)))
(t_4 (+ 2.0 (* 2.0 i)))
(t_5 (+ beta t_4)))
(if (<= t_3 -0.999999995)
(/ (/ (+ t_1 t_5) alpha) 2.0)
(if (<= t_3 2e-5)
(/ (+ 1.0 (/ t_2 (* (+ (+ alpha beta) t_4) (+ alpha t_1)))) 2.0)
(/ (fma (/ beta t_5) (/ 1.0 (/ t_1 beta)) 1.0) 2.0)))))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
double t_1 = beta + (2.0 * i);
double t_2 = (alpha + beta) * (beta - alpha);
double t_3 = (t_2 / t_0) / (2.0 + t_0);
double t_4 = 2.0 + (2.0 * i);
double t_5 = beta + t_4;
double tmp;
if (t_3 <= -0.999999995) {
tmp = ((t_1 + t_5) / alpha) / 2.0;
} else if (t_3 <= 2e-5) {
tmp = (1.0 + (t_2 / (((alpha + beta) + t_4) * (alpha + t_1)))) / 2.0;
} else {
tmp = fma((beta / t_5), (1.0 / (t_1 / beta)), 1.0) / 2.0;
}
return tmp;
}
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_1 = Float64(beta + Float64(2.0 * i)) t_2 = Float64(Float64(alpha + beta) * Float64(beta - alpha)) t_3 = Float64(Float64(t_2 / t_0) / Float64(2.0 + t_0)) t_4 = Float64(2.0 + Float64(2.0 * i)) t_5 = Float64(beta + t_4) tmp = 0.0 if (t_3 <= -0.999999995) tmp = Float64(Float64(Float64(t_1 + t_5) / alpha) / 2.0); elseif (t_3 <= 2e-5) tmp = Float64(Float64(1.0 + Float64(t_2 / Float64(Float64(Float64(alpha + beta) + t_4) * Float64(alpha + t_1)))) / 2.0); else tmp = Float64(fma(Float64(beta / t_5), Float64(1.0 / Float64(t_1 / 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]}, Block[{t$95$1 = N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t$95$2 / t$95$0), $MachinePrecision] / N[(2.0 + t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(beta + t$95$4), $MachinePrecision]}, If[LessEqual[t$95$3, -0.999999995], N[(N[(N[(t$95$1 + t$95$5), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[t$95$3, 2e-5], N[(N[(1.0 + N[(t$95$2 / N[(N[(N[(alpha + beta), $MachinePrecision] + t$95$4), $MachinePrecision] * N[(alpha + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(beta / t$95$5), $MachinePrecision] * N[(1.0 / N[(t$95$1 / beta), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_1 := \beta + 2 \cdot i\\
t_2 := \left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)\\
t_3 := \frac{\frac{t_2}{t_0}}{2 + t_0}\\
t_4 := 2 + 2 \cdot i\\
t_5 := \beta + t_4\\
\mathbf{if}\;t_3 \leq -0.999999995:\\
\;\;\;\;\frac{\frac{t_1 + t_5}{\alpha}}{2}\\
\mathbf{elif}\;t_3 \leq 2 \cdot 10^{-5}:\\
\;\;\;\;\frac{1 + \frac{t_2}{\left(\left(\alpha + \beta\right) + t_4\right) \cdot \left(\alpha + t_1\right)}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{\beta}{t_5}, \frac{1}{\frac{t_1}{\beta}}, 1\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.99999999500000003Initial program 4.8%
associate-/l/4.0%
*-commutative4.0%
times-frac15.6%
fma-def15.6%
associate-+l+15.6%
fma-def15.6%
associate-+l+15.6%
+-commutative15.6%
fma-def15.6%
Simplified15.6%
Taylor expanded in alpha around inf 91.6%
if -0.99999999500000003 < (/.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.1%
associate-/l/99.1%
associate-+l+99.1%
associate-+l+99.1%
Simplified99.1%
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 45.1%
associate-/l/43.4%
*-commutative43.4%
times-frac100.0%
fma-def100.0%
associate-+l+100.0%
fma-def100.0%
associate-+l+100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
clear-num100.0%
inv-pow100.0%
+-commutative100.0%
Applied egg-rr100.0%
unpow-1100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in alpha around 0 100.0%
Taylor expanded in alpha around 0 100.0%
Final simplification97.5%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) (* 2.0 i)))
(t_1 (+ beta (* 2.0 i)))
(t_2 (* (+ alpha beta) (- beta alpha)))
(t_3 (/ (/ t_2 t_0) (+ 2.0 t_0)))
(t_4 (+ 2.0 (* 2.0 i)))
(t_5 (+ beta t_4)))
(if (<= t_3 -0.999999995)
(/ (/ (+ t_1 t_5) alpha) 2.0)
(if (<= t_3 1.0)
(/ (+ 1.0 (/ t_2 (* (+ (+ alpha beta) t_4) (+ alpha t_1)))) 2.0)
(/ (+ 1.0 (/ beta t_5)) 2.0)))))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
double t_1 = beta + (2.0 * i);
double t_2 = (alpha + beta) * (beta - alpha);
double t_3 = (t_2 / t_0) / (2.0 + t_0);
double t_4 = 2.0 + (2.0 * i);
double t_5 = beta + t_4;
double tmp;
if (t_3 <= -0.999999995) {
tmp = ((t_1 + t_5) / alpha) / 2.0;
} else if (t_3 <= 1.0) {
tmp = (1.0 + (t_2 / (((alpha + beta) + t_4) * (alpha + t_1)))) / 2.0;
} else {
tmp = (1.0 + (beta / t_5)) / 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) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: tmp
t_0 = (alpha + beta) + (2.0d0 * i)
t_1 = beta + (2.0d0 * i)
t_2 = (alpha + beta) * (beta - alpha)
t_3 = (t_2 / t_0) / (2.0d0 + t_0)
t_4 = 2.0d0 + (2.0d0 * i)
t_5 = beta + t_4
if (t_3 <= (-0.999999995d0)) then
tmp = ((t_1 + t_5) / alpha) / 2.0d0
else if (t_3 <= 1.0d0) then
tmp = (1.0d0 + (t_2 / (((alpha + beta) + t_4) * (alpha + t_1)))) / 2.0d0
else
tmp = (1.0d0 + (beta / t_5)) / 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 = beta + (2.0 * i);
double t_2 = (alpha + beta) * (beta - alpha);
double t_3 = (t_2 / t_0) / (2.0 + t_0);
double t_4 = 2.0 + (2.0 * i);
double t_5 = beta + t_4;
double tmp;
if (t_3 <= -0.999999995) {
tmp = ((t_1 + t_5) / alpha) / 2.0;
} else if (t_3 <= 1.0) {
tmp = (1.0 + (t_2 / (((alpha + beta) + t_4) * (alpha + t_1)))) / 2.0;
} else {
tmp = (1.0 + (beta / t_5)) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = (alpha + beta) + (2.0 * i) t_1 = beta + (2.0 * i) t_2 = (alpha + beta) * (beta - alpha) t_3 = (t_2 / t_0) / (2.0 + t_0) t_4 = 2.0 + (2.0 * i) t_5 = beta + t_4 tmp = 0 if t_3 <= -0.999999995: tmp = ((t_1 + t_5) / alpha) / 2.0 elif t_3 <= 1.0: tmp = (1.0 + (t_2 / (((alpha + beta) + t_4) * (alpha + t_1)))) / 2.0 else: tmp = (1.0 + (beta / t_5)) / 2.0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_1 = Float64(beta + Float64(2.0 * i)) t_2 = Float64(Float64(alpha + beta) * Float64(beta - alpha)) t_3 = Float64(Float64(t_2 / t_0) / Float64(2.0 + t_0)) t_4 = Float64(2.0 + Float64(2.0 * i)) t_5 = Float64(beta + t_4) tmp = 0.0 if (t_3 <= -0.999999995) tmp = Float64(Float64(Float64(t_1 + t_5) / alpha) / 2.0); elseif (t_3 <= 1.0) tmp = Float64(Float64(1.0 + Float64(t_2 / Float64(Float64(Float64(alpha + beta) + t_4) * Float64(alpha + t_1)))) / 2.0); else tmp = Float64(Float64(1.0 + Float64(beta / t_5)) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = (alpha + beta) + (2.0 * i); t_1 = beta + (2.0 * i); t_2 = (alpha + beta) * (beta - alpha); t_3 = (t_2 / t_0) / (2.0 + t_0); t_4 = 2.0 + (2.0 * i); t_5 = beta + t_4; tmp = 0.0; if (t_3 <= -0.999999995) tmp = ((t_1 + t_5) / alpha) / 2.0; elseif (t_3 <= 1.0) tmp = (1.0 + (t_2 / (((alpha + beta) + t_4) * (alpha + t_1)))) / 2.0; else tmp = (1.0 + (beta / t_5)) / 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[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t$95$2 / t$95$0), $MachinePrecision] / N[(2.0 + t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(beta + t$95$4), $MachinePrecision]}, If[LessEqual[t$95$3, -0.999999995], N[(N[(N[(t$95$1 + t$95$5), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[t$95$3, 1.0], N[(N[(1.0 + N[(t$95$2 / N[(N[(N[(alpha + beta), $MachinePrecision] + t$95$4), $MachinePrecision] * N[(alpha + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(1.0 + N[(beta / t$95$5), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_1 := \beta + 2 \cdot i\\
t_2 := \left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)\\
t_3 := \frac{\frac{t_2}{t_0}}{2 + t_0}\\
t_4 := 2 + 2 \cdot i\\
t_5 := \beta + t_4\\
\mathbf{if}\;t_3 \leq -0.999999995:\\
\;\;\;\;\frac{\frac{t_1 + t_5}{\alpha}}{2}\\
\mathbf{elif}\;t_3 \leq 1:\\
\;\;\;\;\frac{1 + \frac{t_2}{\left(\left(\alpha + \beta\right) + t_4\right) \cdot \left(\alpha + t_1\right)}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 + \frac{\beta}{t_5}}{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.99999999500000003Initial program 4.8%
associate-/l/4.0%
*-commutative4.0%
times-frac15.6%
fma-def15.6%
associate-+l+15.6%
fma-def15.6%
associate-+l+15.6%
+-commutative15.6%
fma-def15.6%
Simplified15.6%
Taylor expanded in alpha around inf 91.6%
if -0.99999999500000003 < (/.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)) < 1Initial program 99.2%
associate-/l/99.3%
associate-+l+99.3%
associate-+l+99.3%
Simplified99.3%
if 1 < (/.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 6.2%
Taylor expanded in beta around inf 97.1%
Taylor expanded in alpha around 0 97.1%
Final simplification97.2%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ beta (+ 2.0 (* 2.0 i)))) (t_1 (/ (+ 1.0 (/ beta t_0)) 2.0)))
(if (<= alpha 0.108)
t_1
(if (<= alpha 9.5e+17)
(/
(-
1.0
(/
(* alpha alpha)
(* (+ alpha (* 2.0 i)) (+ (* 2.0 i) (+ alpha 2.0)))))
2.0)
(if (<= alpha 1.12e+91)
t_1
(/ (/ (+ (+ beta (* 2.0 i)) t_0) alpha) 2.0))))))
double code(double alpha, double beta, double i) {
double t_0 = beta + (2.0 + (2.0 * i));
double t_1 = (1.0 + (beta / t_0)) / 2.0;
double tmp;
if (alpha <= 0.108) {
tmp = t_1;
} else if (alpha <= 9.5e+17) {
tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0;
} else if (alpha <= 1.12e+91) {
tmp = t_1;
} else {
tmp = (((beta + (2.0 * i)) + t_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) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = beta + (2.0d0 + (2.0d0 * i))
t_1 = (1.0d0 + (beta / t_0)) / 2.0d0
if (alpha <= 0.108d0) then
tmp = t_1
else if (alpha <= 9.5d+17) then
tmp = (1.0d0 - ((alpha * alpha) / ((alpha + (2.0d0 * i)) * ((2.0d0 * i) + (alpha + 2.0d0))))) / 2.0d0
else if (alpha <= 1.12d+91) then
tmp = t_1
else
tmp = (((beta + (2.0d0 * i)) + t_0) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double t_0 = beta + (2.0 + (2.0 * i));
double t_1 = (1.0 + (beta / t_0)) / 2.0;
double tmp;
if (alpha <= 0.108) {
tmp = t_1;
} else if (alpha <= 9.5e+17) {
tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0;
} else if (alpha <= 1.12e+91) {
tmp = t_1;
} else {
tmp = (((beta + (2.0 * i)) + t_0) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = beta + (2.0 + (2.0 * i)) t_1 = (1.0 + (beta / t_0)) / 2.0 tmp = 0 if alpha <= 0.108: tmp = t_1 elif alpha <= 9.5e+17: tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0 elif alpha <= 1.12e+91: tmp = t_1 else: tmp = (((beta + (2.0 * i)) + t_0) / alpha) / 2.0 return tmp
function code(alpha, beta, i) t_0 = Float64(beta + Float64(2.0 + Float64(2.0 * i))) t_1 = Float64(Float64(1.0 + Float64(beta / t_0)) / 2.0) tmp = 0.0 if (alpha <= 0.108) tmp = t_1; elseif (alpha <= 9.5e+17) 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 <= 1.12e+91) tmp = t_1; else tmp = Float64(Float64(Float64(Float64(beta + Float64(2.0 * i)) + t_0) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = beta + (2.0 + (2.0 * i)); t_1 = (1.0 + (beta / t_0)) / 2.0; tmp = 0.0; if (alpha <= 0.108) tmp = t_1; elseif (alpha <= 9.5e+17) tmp = (1.0 - ((alpha * alpha) / ((alpha + (2.0 * i)) * ((2.0 * i) + (alpha + 2.0))))) / 2.0; elseif (alpha <= 1.12e+91) tmp = t_1; else tmp = (((beta + (2.0 * i)) + t_0) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 + N[(beta / t$95$0), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]}, If[LessEqual[alpha, 0.108], t$95$1, If[LessEqual[alpha, 9.5e+17], 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, 1.12e+91], t$95$1, N[(N[(N[(N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \beta + \left(2 + 2 \cdot i\right)\\
t_1 := \frac{1 + \frac{\beta}{t_0}}{2}\\
\mathbf{if}\;\alpha \leq 0.108:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\alpha \leq 9.5 \cdot 10^{+17}:\\
\;\;\;\;\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 1.12 \cdot 10^{+91}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\left(\beta + 2 \cdot i\right) + t_0}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 0.107999999999999999 or 9.5e17 < alpha < 1.12e91Initial program 84.2%
Taylor expanded in beta around inf 94.3%
Taylor expanded in alpha around 0 94.3%
if 0.107999999999999999 < alpha < 9.5e17Initial program 68.7%
associate-/l/67.9%
*-commutative67.9%
times-frac80.8%
fma-def80.8%
associate-+l+80.8%
fma-def80.8%
associate-+l+80.8%
+-commutative80.8%
fma-def80.8%
Simplified80.8%
fma-udef80.8%
fma-udef80.8%
+-commutative80.8%
associate-+r+80.8%
+-commutative80.8%
fma-udef80.8%
add-log-exp79.6%
fma-def79.6%
Applied egg-rr79.6%
Taylor expanded in beta around 0 80.4%
mul-1-neg80.4%
unsub-neg80.4%
unpow280.4%
associate-+r+80.4%
+-commutative80.4%
Simplified80.4%
if 1.12e91 < alpha Initial program 4.0%
associate-/l/2.9%
*-commutative2.9%
times-frac23.8%
fma-def23.8%
associate-+l+23.8%
fma-def23.8%
associate-+l+23.8%
+-commutative23.8%
fma-def23.8%
Simplified23.8%
Taylor expanded in alpha around inf 82.6%
Final simplification91.2%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ beta (+ 2.0 (* 2.0 i)))))
(if (<= alpha 1.12e+91)
(/ (+ 1.0 (/ beta t_0)) 2.0)
(/ (/ (+ (+ beta (* 2.0 i)) t_0) alpha) 2.0))))
double code(double alpha, double beta, double i) {
double t_0 = beta + (2.0 + (2.0 * i));
double tmp;
if (alpha <= 1.12e+91) {
tmp = (1.0 + (beta / t_0)) / 2.0;
} else {
tmp = (((beta + (2.0 * i)) + t_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) :: t_0
real(8) :: tmp
t_0 = beta + (2.0d0 + (2.0d0 * i))
if (alpha <= 1.12d+91) then
tmp = (1.0d0 + (beta / t_0)) / 2.0d0
else
tmp = (((beta + (2.0d0 * i)) + t_0) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double t_0 = beta + (2.0 + (2.0 * i));
double tmp;
if (alpha <= 1.12e+91) {
tmp = (1.0 + (beta / t_0)) / 2.0;
} else {
tmp = (((beta + (2.0 * i)) + t_0) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = beta + (2.0 + (2.0 * i)) tmp = 0 if alpha <= 1.12e+91: tmp = (1.0 + (beta / t_0)) / 2.0 else: tmp = (((beta + (2.0 * i)) + t_0) / alpha) / 2.0 return tmp
function code(alpha, beta, i) t_0 = Float64(beta + Float64(2.0 + Float64(2.0 * i))) tmp = 0.0 if (alpha <= 1.12e+91) tmp = Float64(Float64(1.0 + Float64(beta / t_0)) / 2.0); else tmp = Float64(Float64(Float64(Float64(beta + Float64(2.0 * i)) + t_0) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = beta + (2.0 + (2.0 * i)); tmp = 0.0; if (alpha <= 1.12e+91) tmp = (1.0 + (beta / t_0)) / 2.0; else tmp = (((beta + (2.0 * i)) + t_0) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[alpha, 1.12e+91], N[(N[(1.0 + N[(beta / t$95$0), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \beta + \left(2 + 2 \cdot i\right)\\
\mathbf{if}\;\alpha \leq 1.12 \cdot 10^{+91}:\\
\;\;\;\;\frac{1 + \frac{\beta}{t_0}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\left(\beta + 2 \cdot i\right) + t_0}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 1.12e91Initial program 83.6%
Taylor expanded in beta around inf 91.5%
Taylor expanded in alpha around 0 91.5%
if 1.12e91 < alpha Initial program 4.0%
associate-/l/2.9%
*-commutative2.9%
times-frac23.8%
fma-def23.8%
associate-+l+23.8%
fma-def23.8%
associate-+l+23.8%
+-commutative23.8%
fma-def23.8%
Simplified23.8%
Taylor expanded in alpha around inf 82.6%
Final simplification89.5%
(FPCore (alpha beta i) :precision binary64 (if (<= i 5e+78) (/ (+ 1.0 (/ (- beta alpha) (+ beta (+ alpha 2.0)))) 2.0) 0.5))
double code(double alpha, double beta, double i) {
double tmp;
if (i <= 5e+78) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else {
tmp = 0.5;
}
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 (i <= 5d+78) then
tmp = (1.0d0 + ((beta - alpha) / (beta + (alpha + 2.0d0)))) / 2.0d0
else
tmp = 0.5d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (i <= 5e+78) {
tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0;
} else {
tmp = 0.5;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if i <= 5e+78: tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0 else: tmp = 0.5 return tmp
function code(alpha, beta, i) tmp = 0.0 if (i <= 5e+78) tmp = Float64(Float64(1.0 + Float64(Float64(beta - alpha) / Float64(beta + Float64(alpha + 2.0)))) / 2.0); else tmp = 0.5; end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (i <= 5e+78) tmp = (1.0 + ((beta - alpha) / (beta + (alpha + 2.0)))) / 2.0; else tmp = 0.5; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[i, 5e+78], N[(N[(1.0 + N[(N[(beta - alpha), $MachinePrecision] / N[(beta + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], 0.5]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq 5 \cdot 10^{+78}:\\
\;\;\;\;\frac{1 + \frac{\beta - \alpha}{\beta + \left(\alpha + 2\right)}}{2}\\
\mathbf{else}:\\
\;\;\;\;0.5\\
\end{array}
\end{array}
if i < 4.99999999999999984e78Initial program 61.6%
associate-/l/61.0%
*-commutative61.0%
times-frac74.2%
fma-def74.2%
associate-+l+74.2%
fma-def74.2%
associate-+l+74.2%
+-commutative74.2%
fma-def74.2%
Simplified74.2%
Taylor expanded in i around 0 71.1%
associate--l+71.1%
div-sub71.1%
+-commutative71.1%
Simplified71.1%
if 4.99999999999999984e78 < i Initial program 73.4%
associate-/l/72.9%
*-commutative72.9%
times-frac89.5%
fma-def89.5%
associate-+l+89.5%
fma-def89.5%
associate-+l+89.5%
+-commutative89.5%
fma-def89.5%
Simplified89.5%
Taylor expanded in i around inf 82.7%
Final simplification75.3%
(FPCore (alpha beta i) :precision binary64 (if (<= alpha 1.12e+91) (/ (+ 1.0 (/ beta (+ beta (+ 2.0 (* 2.0 i))))) 2.0) (/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0)))
double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 1.12e+91) {
tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 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 <= 1.12d+91) then
tmp = (1.0d0 + (beta / (beta + (2.0d0 + (2.0d0 * i))))) / 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 <= 1.12e+91) {
tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 2.0;
} else {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if alpha <= 1.12e+91: tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 2.0 else: tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (alpha <= 1.12e+91) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + Float64(2.0 + Float64(2.0 * i))))) / 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 <= 1.12e+91) tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 2.0; else tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[alpha, 1.12e+91], N[(N[(1.0 + N[(beta / N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $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 1.12 \cdot 10^{+91}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + \left(2 + 2 \cdot i\right)}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 1.12e91Initial program 83.6%
Taylor expanded in beta around inf 91.5%
Taylor expanded in alpha around 0 91.5%
if 1.12e91 < alpha Initial program 4.0%
associate-/l/2.9%
*-commutative2.9%
times-frac23.8%
fma-def23.8%
associate-+l+23.8%
fma-def23.8%
associate-+l+23.8%
+-commutative23.8%
fma-def23.8%
Simplified23.8%
Taylor expanded in i around 0 17.1%
Taylor expanded in alpha around inf 50.0%
Final simplification82.2%
(FPCore (alpha beta i) :precision binary64 (if (<= alpha 1.12e+91) (/ (+ 1.0 (/ beta (+ beta (+ 2.0 (* 2.0 i))))) 2.0) (/ (/ (+ (* i 4.0) (- 2.0 beta)) alpha) 2.0)))
double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 1.12e+91) {
tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 2.0;
} else {
tmp = (((i * 4.0) + (2.0 - beta)) / 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 <= 1.12d+91) then
tmp = (1.0d0 + (beta / (beta + (2.0d0 + (2.0d0 * i))))) / 2.0d0
else
tmp = (((i * 4.0d0) + (2.0d0 - beta)) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 1.12e+91) {
tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 2.0;
} else {
tmp = (((i * 4.0) + (2.0 - beta)) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if alpha <= 1.12e+91: tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 2.0 else: tmp = (((i * 4.0) + (2.0 - beta)) / alpha) / 2.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (alpha <= 1.12e+91) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + Float64(2.0 + Float64(2.0 * i))))) / 2.0); else tmp = Float64(Float64(Float64(Float64(i * 4.0) + Float64(2.0 - beta)) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (alpha <= 1.12e+91) tmp = (1.0 + (beta / (beta + (2.0 + (2.0 * i))))) / 2.0; else tmp = (((i * 4.0) + (2.0 - beta)) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[alpha, 1.12e+91], N[(N[(1.0 + N[(beta / N[(beta + N[(2.0 + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(N[(i * 4.0), $MachinePrecision] + N[(2.0 - beta), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 1.12 \cdot 10^{+91}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + \left(2 + 2 \cdot i\right)}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{i \cdot 4 + \left(2 - \beta\right)}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 1.12e91Initial program 83.6%
Taylor expanded in beta around inf 91.5%
Taylor expanded in alpha around 0 91.5%
if 1.12e91 < alpha Initial program 4.0%
Simplified13.1%
Taylor expanded in beta around 0 11.8%
associate-*r/11.8%
mul-1-neg11.8%
Simplified11.8%
Taylor expanded in alpha around inf 63.1%
Final simplification85.2%
(FPCore (alpha beta i) :precision binary64 (if (<= i 4.2e+89) (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0) 0.5))
double code(double alpha, double beta, double i) {
double tmp;
if (i <= 4.2e+89) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = 0.5;
}
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 (i <= 4.2d+89) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = 0.5d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (i <= 4.2e+89) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = 0.5;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if i <= 4.2e+89: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = 0.5 return tmp
function code(alpha, beta, i) tmp = 0.0 if (i <= 4.2e+89) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = 0.5; end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (i <= 4.2e+89) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = 0.5; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[i, 4.2e+89], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], 0.5]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq 4.2 \cdot 10^{+89}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;0.5\\
\end{array}
\end{array}
if i < 4.19999999999999972e89Initial program 61.0%
associate-/l/60.5%
*-commutative60.5%
times-frac73.8%
fma-def73.8%
associate-+l+73.8%
fma-def73.8%
associate-+l+73.8%
+-commutative73.8%
fma-def73.8%
Simplified73.8%
Taylor expanded in i around 0 70.2%
Taylor expanded in alpha around 0 67.7%
if 4.19999999999999972e89 < i Initial program 75.2%
associate-/l/74.7%
*-commutative74.7%
times-frac91.2%
fma-def91.2%
associate-+l+91.2%
fma-def91.2%
associate-+l+91.2%
+-commutative91.2%
fma-def91.2%
Simplified91.2%
Taylor expanded in i around inf 84.8%
Final simplification73.5%
(FPCore (alpha beta i) :precision binary64 (if (<= beta 4.6e+76) 0.5 1.0))
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.6e+76) {
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 <= 4.6d+76) 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 <= 4.6e+76) {
tmp = 0.5;
} else {
tmp = 1.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if beta <= 4.6e+76: tmp = 0.5 else: tmp = 1.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (beta <= 4.6e+76) tmp = 0.5; else tmp = 1.0; end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (beta <= 4.6e+76) tmp = 0.5; else tmp = 1.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[beta, 4.6e+76], 0.5, 1.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 4.6 \cdot 10^{+76}:\\
\;\;\;\;0.5\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if beta < 4.60000000000000002e76Initial program 74.9%
associate-/l/74.7%
*-commutative74.7%
times-frac76.7%
fma-def76.7%
associate-+l+76.7%
fma-def76.7%
associate-+l+76.7%
+-commutative76.7%
fma-def76.7%
Simplified76.7%
Taylor expanded in i around inf 70.4%
if 4.60000000000000002e76 < beta Initial program 37.5%
associate-/l/35.9%
*-commutative35.9%
times-frac89.3%
fma-def89.3%
associate-+l+89.3%
fma-def89.3%
associate-+l+89.3%
+-commutative89.3%
fma-def89.3%
Simplified89.3%
Taylor expanded in beta around inf 71.0%
Final simplification70.6%
(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 65.8%
associate-/l/65.3%
*-commutative65.3%
times-frac79.7%
fma-def79.7%
associate-+l+79.7%
fma-def79.7%
associate-+l+79.7%
+-commutative79.7%
fma-def79.7%
Simplified79.7%
Taylor expanded in i around inf 61.1%
Final simplification61.1%
herbie shell --seed 2023193
(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))