
(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 10 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))) (t_1 (+ 2.0 t_0)))
(if (<= (/ (/ (* (+ alpha beta) (- beta alpha)) t_0) t_1) -0.9999998)
(/ (/ (+ (- beta beta) (+ (* i 4.0) (+ 2.0 (* beta 2.0)))) alpha) 2.0)
(/ (+ (/ (* (- beta alpha) (/ beta (+ beta (* 2.0 i)))) t_1) 1.0) 2.0))))
double code(double alpha, double beta, double i) {
double t_0 = (alpha + beta) + (2.0 * i);
double t_1 = 2.0 + t_0;
double tmp;
if (((((alpha + beta) * (beta - alpha)) / t_0) / t_1) <= -0.9999998) {
tmp = (((beta - beta) + ((i * 4.0) + (2.0 + (beta * 2.0)))) / alpha) / 2.0;
} else {
tmp = ((((beta - alpha) * (beta / (beta + (2.0 * i)))) / t_1) + 1.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 = 2.0d0 + t_0
if (((((alpha + beta) * (beta - alpha)) / t_0) / t_1) <= (-0.9999998d0)) then
tmp = (((beta - beta) + ((i * 4.0d0) + (2.0d0 + (beta * 2.0d0)))) / alpha) / 2.0d0
else
tmp = ((((beta - alpha) * (beta / (beta + (2.0d0 * i)))) / t_1) + 1.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 = 2.0 + t_0;
double tmp;
if (((((alpha + beta) * (beta - alpha)) / t_0) / t_1) <= -0.9999998) {
tmp = (((beta - beta) + ((i * 4.0) + (2.0 + (beta * 2.0)))) / alpha) / 2.0;
} else {
tmp = ((((beta - alpha) * (beta / (beta + (2.0 * i)))) / t_1) + 1.0) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = (alpha + beta) + (2.0 * i) t_1 = 2.0 + t_0 tmp = 0 if ((((alpha + beta) * (beta - alpha)) / t_0) / t_1) <= -0.9999998: tmp = (((beta - beta) + ((i * 4.0) + (2.0 + (beta * 2.0)))) / alpha) / 2.0 else: tmp = ((((beta - alpha) * (beta / (beta + (2.0 * i)))) / t_1) + 1.0) / 2.0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_1 = Float64(2.0 + t_0) tmp = 0.0 if (Float64(Float64(Float64(Float64(alpha + beta) * Float64(beta - alpha)) / t_0) / t_1) <= -0.9999998) tmp = Float64(Float64(Float64(Float64(beta - beta) + Float64(Float64(i * 4.0) + Float64(2.0 + Float64(beta * 2.0)))) / alpha) / 2.0); else tmp = Float64(Float64(Float64(Float64(Float64(beta - alpha) * Float64(beta / Float64(beta + Float64(2.0 * i)))) / t_1) + 1.0) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = (alpha + beta) + (2.0 * i); t_1 = 2.0 + t_0; tmp = 0.0; if (((((alpha + beta) * (beta - alpha)) / t_0) / t_1) <= -0.9999998) tmp = (((beta - beta) + ((i * 4.0) + (2.0 + (beta * 2.0)))) / alpha) / 2.0; else tmp = ((((beta - alpha) * (beta / (beta + (2.0 * i)))) / t_1) + 1.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[(2.0 + t$95$0), $MachinePrecision]}, If[LessEqual[N[(N[(N[(N[(alpha + beta), $MachinePrecision] * N[(beta - alpha), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$1), $MachinePrecision], -0.9999998], N[(N[(N[(N[(beta - beta), $MachinePrecision] + N[(N[(i * 4.0), $MachinePrecision] + N[(2.0 + N[(beta * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(N[(N[(beta - alpha), $MachinePrecision] * N[(beta / N[(beta + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_1 := 2 + t_0\\
\mathbf{if}\;\frac{\frac{\left(\alpha + \beta\right) \cdot \left(\beta - \alpha\right)}{t_0}}{t_1} \leq -0.9999998:\\
\;\;\;\;\frac{\frac{\left(\beta - \beta\right) + \left(i \cdot 4 + \left(2 + \beta \cdot 2\right)\right)}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\left(\beta - \alpha\right) \cdot \frac{\beta}{\beta + 2 \cdot i}}{t_1} + 1}{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 2.3%
associate-/l/1.4%
*-commutative1.4%
times-frac11.3%
associate-+l+11.3%
fma-def11.3%
+-commutative11.3%
fma-def11.3%
Simplified11.3%
Taylor expanded in alpha around inf 94.3%
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 73.6%
expm1-log1p-u68.8%
expm1-udef68.8%
associate-/l*92.8%
+-commutative92.8%
+-commutative92.8%
fma-udef92.8%
+-commutative92.8%
Applied egg-rr92.8%
expm1-def92.8%
expm1-log1p99.7%
associate-/r/99.7%
*-commutative99.7%
+-commutative99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in alpha around 0 99.7%
Final simplification98.3%
(FPCore (alpha beta i)
:precision binary64
(if (<= alpha 1.4e+86)
(/ (+ 1.0 (/ beta (+ 2.0 (+ (+ alpha beta) (* 2.0 i))))) 2.0)
(if (<= alpha 1.4e+143)
(/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0)
(if (<= alpha 2.85e+155)
(/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)
(/ (/ (+ (+ beta (* 2.0 i)) (+ beta (+ 2.0 (* 2.0 i)))) alpha) 2.0)))))
double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 1.4e+86) {
tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 1.4e+143) {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
} else if (alpha <= 2.85e+155) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (((beta + (2.0 * i)) + (beta + (2.0 + (2.0 * i)))) / 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.4d+86) then
tmp = (1.0d0 + (beta / (2.0d0 + ((alpha + beta) + (2.0d0 * i))))) / 2.0d0
else if (alpha <= 1.4d+143) then
tmp = ((2.0d0 + (beta * 2.0d0)) / alpha) / 2.0d0
else if (alpha <= 2.85d+155) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = (((beta + (2.0d0 * i)) + (beta + (2.0d0 + (2.0d0 * i)))) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double tmp;
if (alpha <= 1.4e+86) {
tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 1.4e+143) {
tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
} else if (alpha <= 2.85e+155) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (((beta + (2.0 * i)) + (beta + (2.0 + (2.0 * i)))) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if alpha <= 1.4e+86: tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0 elif alpha <= 1.4e+143: tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0 elif alpha <= 2.85e+155: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = (((beta + (2.0 * i)) + (beta + (2.0 + (2.0 * i)))) / alpha) / 2.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (alpha <= 1.4e+86) tmp = Float64(Float64(1.0 + Float64(beta / Float64(2.0 + Float64(Float64(alpha + beta) + Float64(2.0 * i))))) / 2.0); elseif (alpha <= 1.4e+143) tmp = Float64(Float64(Float64(2.0 + Float64(beta * 2.0)) / alpha) / 2.0); elseif (alpha <= 2.85e+155) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = Float64(Float64(Float64(Float64(beta + Float64(2.0 * i)) + Float64(beta + Float64(2.0 + Float64(2.0 * i)))) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (alpha <= 1.4e+86) tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0; elseif (alpha <= 1.4e+143) tmp = ((2.0 + (beta * 2.0)) / alpha) / 2.0; elseif (alpha <= 2.85e+155) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = (((beta + (2.0 * i)) + (beta + (2.0 + (2.0 * i)))) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[alpha, 1.4e+86], N[(N[(1.0 + N[(beta / N[(2.0 + N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 1.4e+143], N[(N[(N[(2.0 + N[(beta * 2.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 2.85e+155], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], 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]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 1.4 \cdot 10^{+86}:\\
\;\;\;\;\frac{1 + \frac{\beta}{2 + \left(\left(\alpha + \beta\right) + 2 \cdot i\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 1.4 \cdot 10^{+143}:\\
\;\;\;\;\frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\mathbf{elif}\;\alpha \leq 2.85 \cdot 10^{+155}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\left(\beta + 2 \cdot i\right) + \left(\beta + \left(2 + 2 \cdot i\right)\right)}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 1.40000000000000002e86Initial program 73.3%
Taylor expanded in beta around inf 95.4%
if 1.40000000000000002e86 < alpha < 1.39999999999999999e143Initial program 26.5%
associate-/l/26.2%
*-commutative26.2%
times-frac37.9%
associate-+l+37.9%
fma-def37.9%
+-commutative37.9%
fma-def37.9%
Simplified37.9%
Taylor expanded in i around 0 10.4%
+-commutative10.4%
Simplified10.4%
Taylor expanded in alpha around inf 66.6%
*-commutative66.6%
Simplified66.6%
if 1.39999999999999999e143 < alpha < 2.8499999999999998e155Initial program 41.4%
associate-/l/40.0%
*-commutative40.0%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 41.9%
+-commutative41.9%
Simplified41.9%
Taylor expanded in alpha around 0 99.4%
if 2.8499999999999998e155 < alpha Initial program 1.2%
associate-/l/0.0%
*-commutative0.0%
times-frac14.5%
fma-def14.5%
associate-+l+14.5%
fma-def14.5%
associate-+l+14.5%
+-commutative14.5%
fma-def14.5%
Simplified14.5%
Taylor expanded in alpha around inf 91.0%
Final simplification92.7%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ 2.0 (* beta 2.0))))
(if (<= alpha 1.15e+86)
(/ (+ 1.0 (/ beta (+ 2.0 (+ (+ alpha beta) (* 2.0 i))))) 2.0)
(if (<= alpha 1.1e+143)
(/ (/ t_0 alpha) 2.0)
(if (<= alpha 4.1e+155)
(/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)
(/ (/ (+ (- beta beta) (+ (* i 4.0) t_0)) alpha) 2.0))))))
double code(double alpha, double beta, double i) {
double t_0 = 2.0 + (beta * 2.0);
double tmp;
if (alpha <= 1.15e+86) {
tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 1.1e+143) {
tmp = (t_0 / alpha) / 2.0;
} else if (alpha <= 4.1e+155) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (((beta - beta) + ((i * 4.0) + 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 = 2.0d0 + (beta * 2.0d0)
if (alpha <= 1.15d+86) then
tmp = (1.0d0 + (beta / (2.0d0 + ((alpha + beta) + (2.0d0 * i))))) / 2.0d0
else if (alpha <= 1.1d+143) then
tmp = (t_0 / alpha) / 2.0d0
else if (alpha <= 4.1d+155) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = (((beta - beta) + ((i * 4.0d0) + t_0)) / alpha) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta, double i) {
double t_0 = 2.0 + (beta * 2.0);
double tmp;
if (alpha <= 1.15e+86) {
tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 1.1e+143) {
tmp = (t_0 / alpha) / 2.0;
} else if (alpha <= 4.1e+155) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (((beta - beta) + ((i * 4.0) + t_0)) / alpha) / 2.0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = 2.0 + (beta * 2.0) tmp = 0 if alpha <= 1.15e+86: tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0 elif alpha <= 1.1e+143: tmp = (t_0 / alpha) / 2.0 elif alpha <= 4.1e+155: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = (((beta - beta) + ((i * 4.0) + t_0)) / alpha) / 2.0 return tmp
function code(alpha, beta, i) t_0 = Float64(2.0 + Float64(beta * 2.0)) tmp = 0.0 if (alpha <= 1.15e+86) tmp = Float64(Float64(1.0 + Float64(beta / Float64(2.0 + Float64(Float64(alpha + beta) + Float64(2.0 * i))))) / 2.0); elseif (alpha <= 1.1e+143) tmp = Float64(Float64(t_0 / alpha) / 2.0); elseif (alpha <= 4.1e+155) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = Float64(Float64(Float64(Float64(beta - beta) + Float64(Float64(i * 4.0) + t_0)) / alpha) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = 2.0 + (beta * 2.0); tmp = 0.0; if (alpha <= 1.15e+86) tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0; elseif (alpha <= 1.1e+143) tmp = (t_0 / alpha) / 2.0; elseif (alpha <= 4.1e+155) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = (((beta - beta) + ((i * 4.0) + t_0)) / alpha) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(2.0 + N[(beta * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[alpha, 1.15e+86], N[(N[(1.0 + N[(beta / N[(2.0 + N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 1.1e+143], N[(N[(t$95$0 / alpha), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 4.1e+155], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(N[(N[(beta - beta), $MachinePrecision] + N[(N[(i * 4.0), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 2 + \beta \cdot 2\\
\mathbf{if}\;\alpha \leq 1.15 \cdot 10^{+86}:\\
\;\;\;\;\frac{1 + \frac{\beta}{2 + \left(\left(\alpha + \beta\right) + 2 \cdot i\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 1.1 \cdot 10^{+143}:\\
\;\;\;\;\frac{\frac{t_0}{\alpha}}{2}\\
\mathbf{elif}\;\alpha \leq 4.1 \cdot 10^{+155}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\left(\beta - \beta\right) + \left(i \cdot 4 + t_0\right)}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 1.14999999999999995e86Initial program 73.3%
Taylor expanded in beta around inf 95.4%
if 1.14999999999999995e86 < alpha < 1.10000000000000007e143Initial program 26.5%
associate-/l/26.2%
*-commutative26.2%
times-frac37.9%
associate-+l+37.9%
fma-def37.9%
+-commutative37.9%
fma-def37.9%
Simplified37.9%
Taylor expanded in i around 0 10.4%
+-commutative10.4%
Simplified10.4%
Taylor expanded in alpha around inf 66.6%
*-commutative66.6%
Simplified66.6%
if 1.10000000000000007e143 < alpha < 4.0999999999999998e155Initial program 41.4%
associate-/l/40.0%
*-commutative40.0%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 41.9%
+-commutative41.9%
Simplified41.9%
Taylor expanded in alpha around 0 99.4%
if 4.0999999999999998e155 < alpha Initial program 1.2%
associate-/l/0.0%
*-commutative0.0%
times-frac14.5%
associate-+l+14.5%
fma-def14.5%
+-commutative14.5%
fma-def14.5%
Simplified14.5%
Taylor expanded in alpha around inf 91.1%
Final simplification92.7%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0))
(t_1 (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)))
(if (<= alpha 1.3e+86)
t_1
(if (<= alpha 3.3e+143)
t_0
(if (<= alpha 5.3e+155)
t_1
(if (or (<= alpha 4.2e+205) (not (<= alpha 1.32e+281)))
(/ (/ (+ 2.0 (* i 4.0)) alpha) 2.0)
t_0))))))
double code(double alpha, double beta, double i) {
double t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
double t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0;
double tmp;
if (alpha <= 1.3e+86) {
tmp = t_1;
} else if (alpha <= 3.3e+143) {
tmp = t_0;
} else if (alpha <= 5.3e+155) {
tmp = t_1;
} else if ((alpha <= 4.2e+205) || !(alpha <= 1.32e+281)) {
tmp = ((2.0 + (i * 4.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 + (beta * 2.0d0)) / alpha) / 2.0d0
t_1 = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
if (alpha <= 1.3d+86) then
tmp = t_1
else if (alpha <= 3.3d+143) then
tmp = t_0
else if (alpha <= 5.3d+155) then
tmp = t_1
else if ((alpha <= 4.2d+205) .or. (.not. (alpha <= 1.32d+281))) then
tmp = ((2.0d0 + (i * 4.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 + (beta * 2.0)) / alpha) / 2.0;
double t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0;
double tmp;
if (alpha <= 1.3e+86) {
tmp = t_1;
} else if (alpha <= 3.3e+143) {
tmp = t_0;
} else if (alpha <= 5.3e+155) {
tmp = t_1;
} else if ((alpha <= 4.2e+205) || !(alpha <= 1.32e+281)) {
tmp = ((2.0 + (i * 4.0)) / alpha) / 2.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0 t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0 tmp = 0 if alpha <= 1.3e+86: tmp = t_1 elif alpha <= 3.3e+143: tmp = t_0 elif alpha <= 5.3e+155: tmp = t_1 elif (alpha <= 4.2e+205) or not (alpha <= 1.32e+281): tmp = ((2.0 + (i * 4.0)) / alpha) / 2.0 else: tmp = t_0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(Float64(2.0 + Float64(beta * 2.0)) / alpha) / 2.0) t_1 = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0) tmp = 0.0 if (alpha <= 1.3e+86) tmp = t_1; elseif (alpha <= 3.3e+143) tmp = t_0; elseif (alpha <= 5.3e+155) tmp = t_1; elseif ((alpha <= 4.2e+205) || !(alpha <= 1.32e+281)) tmp = Float64(Float64(Float64(2.0 + Float64(i * 4.0)) / alpha) / 2.0); else tmp = t_0; end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0; t_1 = (1.0 + (beta / (beta + 2.0))) / 2.0; tmp = 0.0; if (alpha <= 1.3e+86) tmp = t_1; elseif (alpha <= 3.3e+143) tmp = t_0; elseif (alpha <= 5.3e+155) tmp = t_1; elseif ((alpha <= 4.2e+205) || ~((alpha <= 1.32e+281))) tmp = ((2.0 + (i * 4.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[(beta * 2.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, 1.3e+86], t$95$1, If[LessEqual[alpha, 3.3e+143], t$95$0, If[LessEqual[alpha, 5.3e+155], t$95$1, If[Or[LessEqual[alpha, 4.2e+205], N[Not[LessEqual[alpha, 1.32e+281]], $MachinePrecision]], N[(N[(N[(2.0 + N[(i * 4.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], t$95$0]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
t_1 := \frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{if}\;\alpha \leq 1.3 \cdot 10^{+86}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\alpha \leq 3.3 \cdot 10^{+143}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\alpha \leq 5.3 \cdot 10^{+155}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\alpha \leq 4.2 \cdot 10^{+205} \lor \neg \left(\alpha \leq 1.32 \cdot 10^{+281}\right):\\
\;\;\;\;\frac{\frac{2 + i \cdot 4}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if alpha < 1.2999999999999999e86 or 3.3e143 < alpha < 5.29999999999999965e155Initial program 72.5%
associate-/l/71.6%
*-commutative71.6%
times-frac97.3%
associate-+l+97.3%
fma-def97.3%
+-commutative97.3%
fma-def97.3%
Simplified97.3%
Taylor expanded in i around 0 85.2%
+-commutative85.2%
Simplified85.2%
Taylor expanded in alpha around 0 88.3%
if 1.2999999999999999e86 < alpha < 3.3e143 or 4.2000000000000001e205 < alpha < 1.32000000000000001e281Initial program 11.4%
associate-/l/10.6%
*-commutative10.6%
times-frac25.4%
associate-+l+25.4%
fma-def25.4%
+-commutative25.4%
fma-def25.4%
Simplified25.4%
Taylor expanded in i around 0 9.6%
+-commutative9.6%
Simplified9.6%
Taylor expanded in alpha around inf 72.9%
*-commutative72.9%
Simplified72.9%
if 5.29999999999999965e155 < alpha < 4.2000000000000001e205 or 1.32000000000000001e281 < alpha Initial program 1.1%
associate-/l/0.0%
*-commutative0.0%
times-frac12.3%
associate-+l+12.3%
fma-def12.3%
+-commutative12.3%
fma-def12.3%
Simplified12.3%
Taylor expanded in alpha around inf 93.0%
Taylor expanded in beta around 0 85.2%
Final simplification85.5%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0)))
(if (<= alpha 5.3e+85)
(/ (+ 1.0 (/ beta (+ beta (+ alpha 2.0)))) 2.0)
(if (<= alpha 2.5e+143)
t_0
(if (<= alpha 3.4e+155)
(/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)
(if (or (<= alpha 6.2e+203) (not (<= alpha 1.4e+281)))
(/ (/ (+ 2.0 (* i 4.0)) alpha) 2.0)
t_0))))))
double code(double alpha, double beta, double i) {
double t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
double tmp;
if (alpha <= 5.3e+85) {
tmp = (1.0 + (beta / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 2.5e+143) {
tmp = t_0;
} else if (alpha <= 3.4e+155) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else if ((alpha <= 6.2e+203) || !(alpha <= 1.4e+281)) {
tmp = ((2.0 + (i * 4.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) :: tmp
t_0 = ((2.0d0 + (beta * 2.0d0)) / alpha) / 2.0d0
if (alpha <= 5.3d+85) then
tmp = (1.0d0 + (beta / (beta + (alpha + 2.0d0)))) / 2.0d0
else if (alpha <= 2.5d+143) then
tmp = t_0
else if (alpha <= 3.4d+155) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else if ((alpha <= 6.2d+203) .or. (.not. (alpha <= 1.4d+281))) then
tmp = ((2.0d0 + (i * 4.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 + (beta * 2.0)) / alpha) / 2.0;
double tmp;
if (alpha <= 5.3e+85) {
tmp = (1.0 + (beta / (beta + (alpha + 2.0)))) / 2.0;
} else if (alpha <= 2.5e+143) {
tmp = t_0;
} else if (alpha <= 3.4e+155) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else if ((alpha <= 6.2e+203) || !(alpha <= 1.4e+281)) {
tmp = ((2.0 + (i * 4.0)) / alpha) / 2.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0 tmp = 0 if alpha <= 5.3e+85: tmp = (1.0 + (beta / (beta + (alpha + 2.0)))) / 2.0 elif alpha <= 2.5e+143: tmp = t_0 elif alpha <= 3.4e+155: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 elif (alpha <= 6.2e+203) or not (alpha <= 1.4e+281): tmp = ((2.0 + (i * 4.0)) / alpha) / 2.0 else: tmp = t_0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(Float64(2.0 + Float64(beta * 2.0)) / alpha) / 2.0) tmp = 0.0 if (alpha <= 5.3e+85) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + Float64(alpha + 2.0)))) / 2.0); elseif (alpha <= 2.5e+143) tmp = t_0; elseif (alpha <= 3.4e+155) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); elseif ((alpha <= 6.2e+203) || !(alpha <= 1.4e+281)) tmp = Float64(Float64(Float64(2.0 + Float64(i * 4.0)) / alpha) / 2.0); else tmp = t_0; end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0; tmp = 0.0; if (alpha <= 5.3e+85) tmp = (1.0 + (beta / (beta + (alpha + 2.0)))) / 2.0; elseif (alpha <= 2.5e+143) tmp = t_0; elseif (alpha <= 3.4e+155) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; elseif ((alpha <= 6.2e+203) || ~((alpha <= 1.4e+281))) tmp = ((2.0 + (i * 4.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[(beta * 2.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]}, If[LessEqual[alpha, 5.3e+85], N[(N[(1.0 + N[(beta / N[(beta + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 2.5e+143], t$95$0, If[LessEqual[alpha, 3.4e+155], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[Or[LessEqual[alpha, 6.2e+203], N[Not[LessEqual[alpha, 1.4e+281]], $MachinePrecision]], N[(N[(N[(2.0 + N[(i * 4.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], t$95$0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\mathbf{if}\;\alpha \leq 5.3 \cdot 10^{+85}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + \left(\alpha + 2\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 2.5 \cdot 10^{+143}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\alpha \leq 3.4 \cdot 10^{+155}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{elif}\;\alpha \leq 6.2 \cdot 10^{+203} \lor \neg \left(\alpha \leq 1.4 \cdot 10^{+281}\right):\\
\;\;\;\;\frac{\frac{2 + i \cdot 4}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if alpha < 5.2999999999999999e85Initial program 73.3%
Taylor expanded in beta around inf 95.4%
Taylor expanded in i around 0 88.5%
+-commutative88.5%
Simplified88.5%
if 5.2999999999999999e85 < alpha < 2.50000000000000006e143 or 6.2e203 < alpha < 1.4e281Initial program 11.4%
associate-/l/10.6%
*-commutative10.6%
times-frac25.4%
associate-+l+25.4%
fma-def25.4%
+-commutative25.4%
fma-def25.4%
Simplified25.4%
Taylor expanded in i around 0 9.6%
+-commutative9.6%
Simplified9.6%
Taylor expanded in alpha around inf 72.9%
*-commutative72.9%
Simplified72.9%
if 2.50000000000000006e143 < alpha < 3.4000000000000001e155Initial program 41.4%
associate-/l/40.0%
*-commutative40.0%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 41.9%
+-commutative41.9%
Simplified41.9%
Taylor expanded in alpha around 0 99.4%
if 3.4000000000000001e155 < alpha < 6.2e203 or 1.4e281 < alpha Initial program 1.1%
associate-/l/0.0%
*-commutative0.0%
times-frac12.3%
associate-+l+12.3%
fma-def12.3%
+-commutative12.3%
fma-def12.3%
Simplified12.3%
Taylor expanded in alpha around inf 93.0%
Taylor expanded in beta around 0 85.2%
Final simplification85.8%
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (/ (/ (+ 2.0 (* beta 2.0)) alpha) 2.0)))
(if (<= alpha 1e+86)
(/ (+ 1.0 (/ beta (+ 2.0 (+ (+ alpha beta) (* 2.0 i))))) 2.0)
(if (<= alpha 1.15e+143)
t_0
(if (<= alpha 1.85e+156)
(/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0)
(if (or (<= alpha 4.8e+200) (not (<= alpha 1.2e+281)))
(/ (/ (+ 2.0 (* i 4.0)) alpha) 2.0)
t_0))))))
double code(double alpha, double beta, double i) {
double t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0;
double tmp;
if (alpha <= 1e+86) {
tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 1.15e+143) {
tmp = t_0;
} else if (alpha <= 1.85e+156) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else if ((alpha <= 4.8e+200) || !(alpha <= 1.2e+281)) {
tmp = ((2.0 + (i * 4.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) :: tmp
t_0 = ((2.0d0 + (beta * 2.0d0)) / alpha) / 2.0d0
if (alpha <= 1d+86) then
tmp = (1.0d0 + (beta / (2.0d0 + ((alpha + beta) + (2.0d0 * i))))) / 2.0d0
else if (alpha <= 1.15d+143) then
tmp = t_0
else if (alpha <= 1.85d+156) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else if ((alpha <= 4.8d+200) .or. (.not. (alpha <= 1.2d+281))) then
tmp = ((2.0d0 + (i * 4.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 + (beta * 2.0)) / alpha) / 2.0;
double tmp;
if (alpha <= 1e+86) {
tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0;
} else if (alpha <= 1.15e+143) {
tmp = t_0;
} else if (alpha <= 1.85e+156) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else if ((alpha <= 4.8e+200) || !(alpha <= 1.2e+281)) {
tmp = ((2.0 + (i * 4.0)) / alpha) / 2.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(alpha, beta, i): t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0 tmp = 0 if alpha <= 1e+86: tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0 elif alpha <= 1.15e+143: tmp = t_0 elif alpha <= 1.85e+156: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 elif (alpha <= 4.8e+200) or not (alpha <= 1.2e+281): tmp = ((2.0 + (i * 4.0)) / alpha) / 2.0 else: tmp = t_0 return tmp
function code(alpha, beta, i) t_0 = Float64(Float64(Float64(2.0 + Float64(beta * 2.0)) / alpha) / 2.0) tmp = 0.0 if (alpha <= 1e+86) tmp = Float64(Float64(1.0 + Float64(beta / Float64(2.0 + Float64(Float64(alpha + beta) + Float64(2.0 * i))))) / 2.0); elseif (alpha <= 1.15e+143) tmp = t_0; elseif (alpha <= 1.85e+156) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); elseif ((alpha <= 4.8e+200) || !(alpha <= 1.2e+281)) tmp = Float64(Float64(Float64(2.0 + Float64(i * 4.0)) / alpha) / 2.0); else tmp = t_0; end return tmp end
function tmp_2 = code(alpha, beta, i) t_0 = ((2.0 + (beta * 2.0)) / alpha) / 2.0; tmp = 0.0; if (alpha <= 1e+86) tmp = (1.0 + (beta / (2.0 + ((alpha + beta) + (2.0 * i))))) / 2.0; elseif (alpha <= 1.15e+143) tmp = t_0; elseif (alpha <= 1.85e+156) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; elseif ((alpha <= 4.8e+200) || ~((alpha <= 1.2e+281))) tmp = ((2.0 + (i * 4.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[(beta * 2.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision]}, If[LessEqual[alpha, 1e+86], N[(N[(1.0 + N[(beta / N[(2.0 + N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[alpha, 1.15e+143], t$95$0, If[LessEqual[alpha, 1.85e+156], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[Or[LessEqual[alpha, 4.8e+200], N[Not[LessEqual[alpha, 1.2e+281]], $MachinePrecision]], N[(N[(N[(2.0 + N[(i * 4.0), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision] / 2.0), $MachinePrecision], t$95$0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\mathbf{if}\;\alpha \leq 10^{+86}:\\
\;\;\;\;\frac{1 + \frac{\beta}{2 + \left(\left(\alpha + \beta\right) + 2 \cdot i\right)}}{2}\\
\mathbf{elif}\;\alpha \leq 1.15 \cdot 10^{+143}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\alpha \leq 1.85 \cdot 10^{+156}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{elif}\;\alpha \leq 4.8 \cdot 10^{+200} \lor \neg \left(\alpha \leq 1.2 \cdot 10^{+281}\right):\\
\;\;\;\;\frac{\frac{2 + i \cdot 4}{\alpha}}{2}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if alpha < 1e86Initial program 73.3%
Taylor expanded in beta around inf 95.4%
if 1e86 < alpha < 1.15e143 or 4.8000000000000001e200 < alpha < 1.2e281Initial program 11.4%
associate-/l/10.6%
*-commutative10.6%
times-frac25.4%
associate-+l+25.4%
fma-def25.4%
+-commutative25.4%
fma-def25.4%
Simplified25.4%
Taylor expanded in i around 0 9.6%
+-commutative9.6%
Simplified9.6%
Taylor expanded in alpha around inf 72.9%
*-commutative72.9%
Simplified72.9%
if 1.15e143 < alpha < 1.85000000000000001e156Initial program 41.4%
associate-/l/40.0%
*-commutative40.0%
times-frac100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in i around 0 41.9%
+-commutative41.9%
Simplified41.9%
Taylor expanded in alpha around 0 99.4%
if 1.85000000000000001e156 < alpha < 4.8000000000000001e200 or 1.2e281 < alpha Initial program 1.1%
associate-/l/0.0%
*-commutative0.0%
times-frac12.3%
associate-+l+12.3%
fma-def12.3%
+-commutative12.3%
fma-def12.3%
Simplified12.3%
Taylor expanded in alpha around inf 93.0%
Taylor expanded in beta around 0 85.2%
Final simplification90.7%
(FPCore (alpha beta i) :precision binary64 (if (or (<= alpha 7e+85) (and (not (<= alpha 1.8e+143)) (<= alpha 2.1e+156))) (/ (+ 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 <= 7e+85) || (!(alpha <= 1.8e+143) && (alpha <= 2.1e+156))) {
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 <= 7d+85) .or. (.not. (alpha <= 1.8d+143)) .and. (alpha <= 2.1d+156)) 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 <= 7e+85) || (!(alpha <= 1.8e+143) && (alpha <= 2.1e+156))) {
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 <= 7e+85) or (not (alpha <= 1.8e+143) and (alpha <= 2.1e+156)): 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 <= 7e+85) || (!(alpha <= 1.8e+143) && (alpha <= 2.1e+156))) 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 <= 7e+85) || (~((alpha <= 1.8e+143)) && (alpha <= 2.1e+156))) 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[Or[LessEqual[alpha, 7e+85], And[N[Not[LessEqual[alpha, 1.8e+143]], $MachinePrecision], LessEqual[alpha, 2.1e+156]]], 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 7 \cdot 10^{+85} \lor \neg \left(\alpha \leq 1.8 \cdot 10^{+143}\right) \land \alpha \leq 2.1 \cdot 10^{+156}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2 + \beta \cdot 2}{\alpha}}{2}\\
\end{array}
\end{array}
if alpha < 7.0000000000000001e85 or 1.8e143 < alpha < 2.09999999999999981e156Initial program 72.5%
associate-/l/71.6%
*-commutative71.6%
times-frac97.3%
associate-+l+97.3%
fma-def97.3%
+-commutative97.3%
fma-def97.3%
Simplified97.3%
Taylor expanded in i around 0 85.2%
+-commutative85.2%
Simplified85.2%
Taylor expanded in alpha around 0 88.3%
if 7.0000000000000001e85 < alpha < 1.8e143 or 2.09999999999999981e156 < alpha Initial program 7.4%
associate-/l/6.5%
*-commutative6.5%
times-frac20.3%
associate-+l+20.3%
fma-def20.3%
+-commutative20.3%
fma-def20.3%
Simplified20.3%
Taylor expanded in i around 0 9.3%
+-commutative9.3%
Simplified9.3%
Taylor expanded in alpha around inf 67.3%
*-commutative67.3%
Simplified67.3%
Final simplification82.6%
(FPCore (alpha beta i) :precision binary64 (if (<= i 4.6e+125) (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0) 0.5))
double code(double alpha, double beta, double i) {
double tmp;
if (i <= 4.6e+125) {
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.6d+125) 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.6e+125) {
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.6e+125: 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.6e+125) 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.6e+125) 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.6e+125], 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.6 \cdot 10^{+125}:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;0.5\\
\end{array}
\end{array}
if i < 4.60000000000000026e125Initial program 49.9%
associate-/l/48.9%
*-commutative48.9%
times-frac72.1%
associate-+l+72.1%
fma-def72.1%
+-commutative72.1%
fma-def72.1%
Simplified72.1%
Taylor expanded in i around 0 69.0%
+-commutative69.0%
Simplified69.0%
Taylor expanded in alpha around 0 69.0%
if 4.60000000000000026e125 < i Initial program 69.8%
associate-/l/69.2%
*-commutative69.2%
times-frac89.6%
associate-+l+89.6%
fma-def89.6%
+-commutative89.6%
fma-def89.6%
Simplified89.6%
Taylor expanded in i around inf 83.8%
Final simplification72.7%
(FPCore (alpha beta i) :precision binary64 (if (<= beta 1.2e+35) 0.5 1.0))
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 1.2e+35) {
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.2d+35) 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.2e+35) {
tmp = 0.5;
} else {
tmp = 1.0;
}
return tmp;
}
def code(alpha, beta, i): tmp = 0 if beta <= 1.2e+35: tmp = 0.5 else: tmp = 1.0 return tmp
function code(alpha, beta, i) tmp = 0.0 if (beta <= 1.2e+35) tmp = 0.5; else tmp = 1.0; end return tmp end
function tmp_2 = code(alpha, beta, i) tmp = 0.0; if (beta <= 1.2e+35) tmp = 0.5; else tmp = 1.0; end tmp_2 = tmp; end
code[alpha_, beta_, i_] := If[LessEqual[beta, 1.2e+35], 0.5, 1.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.2 \cdot 10^{+35}:\\
\;\;\;\;0.5\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if beta < 1.20000000000000007e35Initial program 68.2%
associate-/l/67.9%
*-commutative67.9%
times-frac71.0%
associate-+l+71.0%
fma-def71.0%
+-commutative71.0%
fma-def71.0%
Simplified71.0%
Taylor expanded in i around inf 67.6%
if 1.20000000000000007e35 < beta Initial program 31.7%
associate-/l/29.9%
*-commutative29.9%
times-frac86.3%
associate-+l+86.3%
fma-def86.3%
+-commutative86.3%
fma-def86.3%
Simplified86.3%
Taylor expanded in beta around inf 73.3%
Final simplification69.7%
(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 54.9%
associate-/l/54.1%
*-commutative54.1%
times-frac76.6%
associate-+l+76.6%
fma-def76.6%
+-commutative76.6%
fma-def76.6%
Simplified76.6%
Taylor expanded in i around inf 53.3%
Final simplification53.3%
herbie shell --seed 2023200
(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))