
(FPCore (alpha beta) :precision binary64 (let* ((t_0 (+ (+ alpha beta) (* 2.0 1.0)))) (/ (/ (/ (+ (+ (+ alpha beta) (* beta alpha)) 1.0) t_0) t_0) (+ t_0 1.0))))
double code(double alpha, double beta) {
double t_0 = (alpha + beta) + (2.0 * 1.0);
return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: t_0
t_0 = (alpha + beta) + (2.0d0 * 1.0d0)
code = (((((alpha + beta) + (beta * alpha)) + 1.0d0) / t_0) / t_0) / (t_0 + 1.0d0)
end function
public static double code(double alpha, double beta) {
double t_0 = (alpha + beta) + (2.0 * 1.0);
return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}
def code(alpha, beta): t_0 = (alpha + beta) + (2.0 * 1.0) return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0)
function code(alpha, beta) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * 1.0)) return Float64(Float64(Float64(Float64(Float64(Float64(alpha + beta) + Float64(beta * alpha)) + 1.0) / t_0) / t_0) / Float64(t_0 + 1.0)) end
function tmp = code(alpha, beta) t_0 = (alpha + beta) + (2.0 * 1.0); tmp = (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0); end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(N[(N[(alpha + beta), $MachinePrecision] + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot 1\\
\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{t_0}}{t_0}}{t_0 + 1}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 13 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (alpha beta) :precision binary64 (let* ((t_0 (+ (+ alpha beta) (* 2.0 1.0)))) (/ (/ (/ (+ (+ (+ alpha beta) (* beta alpha)) 1.0) t_0) t_0) (+ t_0 1.0))))
double code(double alpha, double beta) {
double t_0 = (alpha + beta) + (2.0 * 1.0);
return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: t_0
t_0 = (alpha + beta) + (2.0d0 * 1.0d0)
code = (((((alpha + beta) + (beta * alpha)) + 1.0d0) / t_0) / t_0) / (t_0 + 1.0d0)
end function
public static double code(double alpha, double beta) {
double t_0 = (alpha + beta) + (2.0 * 1.0);
return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0);
}
def code(alpha, beta): t_0 = (alpha + beta) + (2.0 * 1.0) return (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0)
function code(alpha, beta) t_0 = Float64(Float64(alpha + beta) + Float64(2.0 * 1.0)) return Float64(Float64(Float64(Float64(Float64(Float64(alpha + beta) + Float64(beta * alpha)) + 1.0) / t_0) / t_0) / Float64(t_0 + 1.0)) end
function tmp = code(alpha, beta) t_0 = (alpha + beta) + (2.0 * 1.0); tmp = (((((alpha + beta) + (beta * alpha)) + 1.0) / t_0) / t_0) / (t_0 + 1.0); end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * 1.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(N[(N[(alpha + beta), $MachinePrecision] + N[(beta * alpha), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 2 \cdot 1\\
\frac{\frac{\frac{\left(\left(\alpha + \beta\right) + \beta \cdot \alpha\right) + 1}{t_0}}{t_0}}{t_0 + 1}
\end{array}
\end{array}
(FPCore (alpha beta) :precision binary64 (let* ((t_0 (+ 2.0 (+ beta alpha)))) (/ (/ (* (+ beta 1.0) (/ (+ 1.0 alpha) t_0)) t_0) (+ 1.0 t_0))))
double code(double alpha, double beta) {
double t_0 = 2.0 + (beta + alpha);
return (((beta + 1.0) * ((1.0 + alpha) / t_0)) / t_0) / (1.0 + t_0);
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: t_0
t_0 = 2.0d0 + (beta + alpha)
code = (((beta + 1.0d0) * ((1.0d0 + alpha) / t_0)) / t_0) / (1.0d0 + t_0)
end function
public static double code(double alpha, double beta) {
double t_0 = 2.0 + (beta + alpha);
return (((beta + 1.0) * ((1.0 + alpha) / t_0)) / t_0) / (1.0 + t_0);
}
def code(alpha, beta): t_0 = 2.0 + (beta + alpha) return (((beta + 1.0) * ((1.0 + alpha) / t_0)) / t_0) / (1.0 + t_0)
function code(alpha, beta) t_0 = Float64(2.0 + Float64(beta + alpha)) return Float64(Float64(Float64(Float64(beta + 1.0) * Float64(Float64(1.0 + alpha) / t_0)) / t_0) / Float64(1.0 + t_0)) end
function tmp = code(alpha, beta) t_0 = 2.0 + (beta + alpha); tmp = (((beta + 1.0) * ((1.0 + alpha) / t_0)) / t_0) / (1.0 + t_0); end
code[alpha_, beta_] := Block[{t$95$0 = N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(beta + 1.0), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 2 + \left(\beta + \alpha\right)\\
\frac{\frac{\left(\beta + 1\right) \cdot \frac{1 + \alpha}{t_0}}{t_0}}{1 + t_0}
\end{array}
\end{array}
Initial program 94.4%
div-inv94.4%
+-commutative94.4%
associate-+l+94.4%
*-commutative94.4%
metadata-eval94.4%
+-commutative94.4%
metadata-eval94.4%
+-commutative94.4%
Applied egg-rr94.4%
associate-*l/94.4%
associate-*r/94.4%
*-rgt-identity94.4%
associate-+r+94.4%
*-rgt-identity94.4%
+-commutative94.4%
distribute-rgt1-in94.5%
distribute-lft-in94.5%
+-commutative94.5%
+-commutative94.5%
*-commutative94.5%
+-commutative94.5%
+-commutative94.5%
associate-*r/99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ alpha (+ beta 3.0))) (t_1 (+ alpha (+ beta 2.0))))
(if (<= beta 2e+128)
(* (+ 1.0 alpha) (/ (/ (+ beta 1.0) t_1) (* t_1 t_0)))
(*
(/ (- 1.0 (/ alpha beta)) (+ 2.0 (+ beta alpha)))
(/ (+ 1.0 alpha) t_0)))))
double code(double alpha, double beta) {
double t_0 = alpha + (beta + 3.0);
double t_1 = alpha + (beta + 2.0);
double tmp;
if (beta <= 2e+128) {
tmp = (1.0 + alpha) * (((beta + 1.0) / t_1) / (t_1 * t_0));
} else {
tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / t_0);
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = alpha + (beta + 3.0d0)
t_1 = alpha + (beta + 2.0d0)
if (beta <= 2d+128) then
tmp = (1.0d0 + alpha) * (((beta + 1.0d0) / t_1) / (t_1 * t_0))
else
tmp = ((1.0d0 - (alpha / beta)) / (2.0d0 + (beta + alpha))) * ((1.0d0 + alpha) / t_0)
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = alpha + (beta + 3.0);
double t_1 = alpha + (beta + 2.0);
double tmp;
if (beta <= 2e+128) {
tmp = (1.0 + alpha) * (((beta + 1.0) / t_1) / (t_1 * t_0));
} else {
tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / t_0);
}
return tmp;
}
def code(alpha, beta): t_0 = alpha + (beta + 3.0) t_1 = alpha + (beta + 2.0) tmp = 0 if beta <= 2e+128: tmp = (1.0 + alpha) * (((beta + 1.0) / t_1) / (t_1 * t_0)) else: tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / t_0) return tmp
function code(alpha, beta) t_0 = Float64(alpha + Float64(beta + 3.0)) t_1 = Float64(alpha + Float64(beta + 2.0)) tmp = 0.0 if (beta <= 2e+128) tmp = Float64(Float64(1.0 + alpha) * Float64(Float64(Float64(beta + 1.0) / t_1) / Float64(t_1 * t_0))); else tmp = Float64(Float64(Float64(1.0 - Float64(alpha / beta)) / Float64(2.0 + Float64(beta + alpha))) * Float64(Float64(1.0 + alpha) / t_0)); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = alpha + (beta + 3.0); t_1 = alpha + (beta + 2.0); tmp = 0.0; if (beta <= 2e+128) tmp = (1.0 + alpha) * (((beta + 1.0) / t_1) / (t_1 * t_0)); else tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / t_0); end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 2e+128], N[(N[(1.0 + alpha), $MachinePrecision] * N[(N[(N[(beta + 1.0), $MachinePrecision] / t$95$1), $MachinePrecision] / N[(t$95$1 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 - N[(alpha / beta), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(\beta + 3\right)\\
t_1 := \alpha + \left(\beta + 2\right)\\
\mathbf{if}\;\beta \leq 2 \cdot 10^{+128}:\\
\;\;\;\;\left(1 + \alpha\right) \cdot \frac{\frac{\beta + 1}{t_1}}{t_1 \cdot t_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{\alpha}{\beta}}{2 + \left(\beta + \alpha\right)} \cdot \frac{1 + \alpha}{t_0}\\
\end{array}
\end{array}
if beta < 2.0000000000000002e128Initial program 99.3%
associate-/l/98.3%
associate-+l+98.3%
+-commutative98.3%
associate-+r+98.3%
associate-+l+98.3%
distribute-rgt1-in98.3%
*-rgt-identity98.3%
distribute-lft-out98.3%
+-commutative98.3%
associate-*l/98.8%
*-commutative98.8%
associate-*r/92.5%
Simplified92.5%
if 2.0000000000000002e128 < beta Initial program 73.7%
associate-/l/71.4%
associate-+l+71.4%
+-commutative71.4%
associate-+r+71.4%
associate-+l+71.4%
distribute-rgt1-in71.4%
*-rgt-identity71.4%
distribute-lft-out71.4%
+-commutative71.4%
associate-*l/89.5%
*-commutative89.5%
associate-*r/89.2%
Simplified89.2%
Taylor expanded in beta around inf 87.5%
mul-1-neg87.5%
unsub-neg87.5%
Simplified87.5%
Taylor expanded in alpha around inf 87.5%
associate-*r/83.4%
associate-+r+83.4%
associate-+r+83.4%
Applied egg-rr83.4%
+-commutative83.4%
*-commutative83.4%
times-frac94.0%
+-commutative94.0%
+-commutative94.0%
associate-+l+94.0%
Simplified94.0%
Final simplification92.8%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ alpha (+ beta 2.0))))
(if (<= beta 1e+55)
(* (/ (+ beta 1.0) (+ beta 3.0)) (/ (+ 1.0 alpha) (* t_0 t_0)))
(*
(/ (- 1.0 (/ alpha beta)) (+ 2.0 (+ beta alpha)))
(/ (+ 1.0 alpha) (+ alpha (+ beta 3.0)))))))
double code(double alpha, double beta) {
double t_0 = alpha + (beta + 2.0);
double tmp;
if (beta <= 1e+55) {
tmp = ((beta + 1.0) / (beta + 3.0)) * ((1.0 + alpha) / (t_0 * t_0));
} else {
tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0)));
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: t_0
real(8) :: tmp
t_0 = alpha + (beta + 2.0d0)
if (beta <= 1d+55) then
tmp = ((beta + 1.0d0) / (beta + 3.0d0)) * ((1.0d0 + alpha) / (t_0 * t_0))
else
tmp = ((1.0d0 - (alpha / beta)) / (2.0d0 + (beta + alpha))) * ((1.0d0 + alpha) / (alpha + (beta + 3.0d0)))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = alpha + (beta + 2.0);
double tmp;
if (beta <= 1e+55) {
tmp = ((beta + 1.0) / (beta + 3.0)) * ((1.0 + alpha) / (t_0 * t_0));
} else {
tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0)));
}
return tmp;
}
def code(alpha, beta): t_0 = alpha + (beta + 2.0) tmp = 0 if beta <= 1e+55: tmp = ((beta + 1.0) / (beta + 3.0)) * ((1.0 + alpha) / (t_0 * t_0)) else: tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0))) return tmp
function code(alpha, beta) t_0 = Float64(alpha + Float64(beta + 2.0)) tmp = 0.0 if (beta <= 1e+55) tmp = Float64(Float64(Float64(beta + 1.0) / Float64(beta + 3.0)) * Float64(Float64(1.0 + alpha) / Float64(t_0 * t_0))); else tmp = Float64(Float64(Float64(1.0 - Float64(alpha / beta)) / Float64(2.0 + Float64(beta + alpha))) * Float64(Float64(1.0 + alpha) / Float64(alpha + Float64(beta + 3.0)))); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = alpha + (beta + 2.0); tmp = 0.0; if (beta <= 1e+55) tmp = ((beta + 1.0) / (beta + 3.0)) * ((1.0 + alpha) / (t_0 * t_0)); else tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0))); end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 1e+55], N[(N[(N[(beta + 1.0), $MachinePrecision] / N[(beta + 3.0), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 - N[(alpha / beta), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(\beta + 2\right)\\
\mathbf{if}\;\beta \leq 10^{+55}:\\
\;\;\;\;\frac{\beta + 1}{\beta + 3} \cdot \frac{1 + \alpha}{t_0 \cdot t_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{\alpha}{\beta}}{2 + \left(\beta + \alpha\right)} \cdot \frac{1 + \alpha}{\alpha + \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 1.00000000000000001e55Initial program 99.9%
associate-/l/99.6%
associate-/l/92.2%
associate-+l+92.2%
+-commutative92.2%
associate-+r+92.2%
associate-+l+92.2%
distribute-rgt1-in92.2%
*-rgt-identity92.2%
distribute-lft-out92.2%
+-commutative92.2%
times-frac99.6%
Simplified99.6%
Taylor expanded in alpha around 0 80.1%
if 1.00000000000000001e55 < beta Initial program 80.6%
associate-/l/76.4%
associate-+l+76.4%
+-commutative76.4%
associate-+r+76.4%
associate-+l+76.4%
distribute-rgt1-in76.4%
*-rgt-identity76.4%
distribute-lft-out76.4%
+-commutative76.4%
associate-*l/90.1%
*-commutative90.1%
associate-*r/89.5%
Simplified89.5%
Taylor expanded in beta around inf 83.9%
mul-1-neg83.9%
unsub-neg83.9%
Simplified83.9%
Taylor expanded in alpha around inf 83.9%
associate-*r/77.0%
associate-+r+77.0%
associate-+r+77.0%
Applied egg-rr77.0%
+-commutative77.0%
*-commutative77.0%
times-frac84.2%
+-commutative84.2%
+-commutative84.2%
associate-+l+84.2%
Simplified84.2%
Final simplification81.3%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 9.5e+54)
(*
(+ 1.0 alpha)
(/ (/ (+ beta 1.0) (+ alpha (+ beta 2.0))) (* (+ beta 2.0) (+ beta 3.0))))
(*
(/ (- 1.0 (/ alpha beta)) (+ 2.0 (+ beta alpha)))
(/ (+ 1.0 alpha) (+ alpha (+ beta 3.0))))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 9.5e+54) {
tmp = (1.0 + alpha) * (((beta + 1.0) / (alpha + (beta + 2.0))) / ((beta + 2.0) * (beta + 3.0)));
} else {
tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0)));
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 9.5d+54) then
tmp = (1.0d0 + alpha) * (((beta + 1.0d0) / (alpha + (beta + 2.0d0))) / ((beta + 2.0d0) * (beta + 3.0d0)))
else
tmp = ((1.0d0 - (alpha / beta)) / (2.0d0 + (beta + alpha))) * ((1.0d0 + alpha) / (alpha + (beta + 3.0d0)))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 9.5e+54) {
tmp = (1.0 + alpha) * (((beta + 1.0) / (alpha + (beta + 2.0))) / ((beta + 2.0) * (beta + 3.0)));
} else {
tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0)));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 9.5e+54: tmp = (1.0 + alpha) * (((beta + 1.0) / (alpha + (beta + 2.0))) / ((beta + 2.0) * (beta + 3.0))) else: tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0))) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 9.5e+54) tmp = Float64(Float64(1.0 + alpha) * Float64(Float64(Float64(beta + 1.0) / Float64(alpha + Float64(beta + 2.0))) / Float64(Float64(beta + 2.0) * Float64(beta + 3.0)))); else tmp = Float64(Float64(Float64(1.0 - Float64(alpha / beta)) / Float64(2.0 + Float64(beta + alpha))) * Float64(Float64(1.0 + alpha) / Float64(alpha + Float64(beta + 3.0)))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 9.5e+54) tmp = (1.0 + alpha) * (((beta + 1.0) / (alpha + (beta + 2.0))) / ((beta + 2.0) * (beta + 3.0))); else tmp = ((1.0 - (alpha / beta)) / (2.0 + (beta + alpha))) * ((1.0 + alpha) / (alpha + (beta + 3.0))); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 9.5e+54], N[(N[(1.0 + alpha), $MachinePrecision] * N[(N[(N[(beta + 1.0), $MachinePrecision] / N[(alpha + N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(beta + 2.0), $MachinePrecision] * N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 - N[(alpha / beta), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 9.5 \cdot 10^{+54}:\\
\;\;\;\;\left(1 + \alpha\right) \cdot \frac{\frac{\beta + 1}{\alpha + \left(\beta + 2\right)}}{\left(\beta + 2\right) \cdot \left(\beta + 3\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - \frac{\alpha}{\beta}}{2 + \left(\beta + \alpha\right)} \cdot \frac{1 + \alpha}{\alpha + \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 9.4999999999999999e54Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/92.7%
Simplified92.7%
Taylor expanded in alpha around 0 67.8%
if 9.4999999999999999e54 < beta Initial program 80.6%
associate-/l/76.4%
associate-+l+76.4%
+-commutative76.4%
associate-+r+76.4%
associate-+l+76.4%
distribute-rgt1-in76.4%
*-rgt-identity76.4%
distribute-lft-out76.4%
+-commutative76.4%
associate-*l/90.1%
*-commutative90.1%
associate-*r/89.5%
Simplified89.5%
Taylor expanded in beta around inf 83.9%
mul-1-neg83.9%
unsub-neg83.9%
Simplified83.9%
Taylor expanded in alpha around inf 83.9%
associate-*r/77.0%
associate-+r+77.0%
associate-+r+77.0%
Applied egg-rr77.0%
+-commutative77.0%
*-commutative77.0%
times-frac84.2%
+-commutative84.2%
+-commutative84.2%
associate-+l+84.2%
Simplified84.2%
Final simplification72.4%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 2e+25)
(/ (+ beta 1.0) (* (+ beta 2.0) (+ 6.0 (* beta (+ beta 5.0)))))
(*
(+ 1.0 alpha)
(/ 1.0 (* (+ alpha (+ beta 2.0)) (+ alpha (+ beta 3.0)))))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2e+25) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = (1.0 + alpha) * (1.0 / ((alpha + (beta + 2.0)) * (alpha + (beta + 3.0))));
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2d+25) then
tmp = (beta + 1.0d0) / ((beta + 2.0d0) * (6.0d0 + (beta * (beta + 5.0d0))))
else
tmp = (1.0d0 + alpha) * (1.0d0 / ((alpha + (beta + 2.0d0)) * (alpha + (beta + 3.0d0))))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2e+25) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = (1.0 + alpha) * (1.0 / ((alpha + (beta + 2.0)) * (alpha + (beta + 3.0))));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2e+25: tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))) else: tmp = (1.0 + alpha) * (1.0 / ((alpha + (beta + 2.0)) * (alpha + (beta + 3.0)))) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2e+25) tmp = Float64(Float64(beta + 1.0) / Float64(Float64(beta + 2.0) * Float64(6.0 + Float64(beta * Float64(beta + 5.0))))); else tmp = Float64(Float64(1.0 + alpha) * Float64(1.0 / Float64(Float64(alpha + Float64(beta + 2.0)) * Float64(alpha + Float64(beta + 3.0))))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2e+25) tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))); else tmp = (1.0 + alpha) * (1.0 / ((alpha + (beta + 2.0)) * (alpha + (beta + 3.0)))); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2e+25], N[(N[(beta + 1.0), $MachinePrecision] / N[(N[(beta + 2.0), $MachinePrecision] * N[(6.0 + N[(beta * N[(beta + 5.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + alpha), $MachinePrecision] * N[(1.0 / N[(N[(alpha + N[(beta + 2.0), $MachinePrecision]), $MachinePrecision] * N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2 \cdot 10^{+25}:\\
\;\;\;\;\frac{\beta + 1}{\left(\beta + 2\right) \cdot \left(6 + \beta \cdot \left(\beta + 5\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(1 + \alpha\right) \cdot \frac{1}{\left(\alpha + \left(\beta + 2\right)\right) \cdot \left(\alpha + \left(\beta + 3\right)\right)}\\
\end{array}
\end{array}
if beta < 2.00000000000000018e25Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/93.2%
Simplified93.2%
Taylor expanded in beta around 0 93.2%
Taylor expanded in alpha around 0 68.9%
unpow268.9%
distribute-rgt-out68.9%
Simplified68.9%
if 2.00000000000000018e25 < beta Initial program 81.4%
associate-/l/77.3%
associate-+l+77.3%
+-commutative77.3%
associate-+r+77.3%
associate-+l+77.3%
distribute-rgt1-in77.3%
*-rgt-identity77.3%
distribute-lft-out77.3%
+-commutative77.3%
associate-*l/90.4%
*-commutative90.4%
associate-*r/88.7%
Simplified88.7%
Taylor expanded in beta around inf 82.3%
Final simplification72.8%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 8.6e+15)
(/ (+ beta 1.0) (* (+ beta 2.0) (+ 6.0 (* beta (+ beta 5.0)))))
(*
(/ (+ beta 1.0) beta)
(/ (/ (+ 1.0 alpha) (+ alpha (+ beta 2.0))) beta))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 8.6e+15) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = ((beta + 1.0) / beta) * (((1.0 + alpha) / (alpha + (beta + 2.0))) / beta);
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 8.6d+15) then
tmp = (beta + 1.0d0) / ((beta + 2.0d0) * (6.0d0 + (beta * (beta + 5.0d0))))
else
tmp = ((beta + 1.0d0) / beta) * (((1.0d0 + alpha) / (alpha + (beta + 2.0d0))) / beta)
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 8.6e+15) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = ((beta + 1.0) / beta) * (((1.0 + alpha) / (alpha + (beta + 2.0))) / beta);
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 8.6e+15: tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))) else: tmp = ((beta + 1.0) / beta) * (((1.0 + alpha) / (alpha + (beta + 2.0))) / beta) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 8.6e+15) tmp = Float64(Float64(beta + 1.0) / Float64(Float64(beta + 2.0) * Float64(6.0 + Float64(beta * Float64(beta + 5.0))))); else tmp = Float64(Float64(Float64(beta + 1.0) / beta) * Float64(Float64(Float64(1.0 + alpha) / Float64(alpha + Float64(beta + 2.0))) / beta)); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 8.6e+15) tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))); else tmp = ((beta + 1.0) / beta) * (((1.0 + alpha) / (alpha + (beta + 2.0))) / beta); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 8.6e+15], N[(N[(beta + 1.0), $MachinePrecision] / N[(N[(beta + 2.0), $MachinePrecision] * N[(6.0 + N[(beta * N[(beta + 5.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(beta + 1.0), $MachinePrecision] / beta), $MachinePrecision] * N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 8.6 \cdot 10^{+15}:\\
\;\;\;\;\frac{\beta + 1}{\left(\beta + 2\right) \cdot \left(6 + \beta \cdot \left(\beta + 5\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\beta + 1}{\beta} \cdot \frac{\frac{1 + \alpha}{\alpha + \left(\beta + 2\right)}}{\beta}\\
\end{array}
\end{array}
if beta < 8.6e15Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/93.6%
Simplified93.6%
Taylor expanded in beta around 0 93.6%
Taylor expanded in alpha around 0 69.0%
unpow269.0%
distribute-rgt-out69.0%
Simplified69.0%
if 8.6e15 < beta Initial program 81.9%
associate-/l/77.9%
associate-+l+77.9%
+-commutative77.9%
associate-+r+77.9%
associate-+l+77.9%
distribute-rgt1-in77.9%
*-rgt-identity77.9%
distribute-lft-out77.9%
+-commutative77.9%
associate-*r/90.6%
associate-*r/78.7%
Simplified78.7%
Taylor expanded in beta around inf 63.1%
unpow274.4%
Simplified63.1%
associate-*r/75.0%
+-commutative75.0%
Applied egg-rr75.0%
times-frac80.2%
+-commutative80.2%
+-commutative80.2%
+-commutative80.2%
Simplified80.2%
Final simplification72.4%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ 2.0 (+ beta alpha))))
(if (<= beta 4.9e+14)
(/ (+ beta 1.0) (* (+ beta 2.0) (+ 6.0 (* beta (+ beta 5.0)))))
(/ (/ (+ 1.0 alpha) t_0) (+ 1.0 t_0)))))
double code(double alpha, double beta) {
double t_0 = 2.0 + (beta + alpha);
double tmp;
if (beta <= 4.9e+14) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = ((1.0 + alpha) / t_0) / (1.0 + t_0);
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: t_0
real(8) :: tmp
t_0 = 2.0d0 + (beta + alpha)
if (beta <= 4.9d+14) then
tmp = (beta + 1.0d0) / ((beta + 2.0d0) * (6.0d0 + (beta * (beta + 5.0d0))))
else
tmp = ((1.0d0 + alpha) / t_0) / (1.0d0 + t_0)
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = 2.0 + (beta + alpha);
double tmp;
if (beta <= 4.9e+14) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = ((1.0 + alpha) / t_0) / (1.0 + t_0);
}
return tmp;
}
def code(alpha, beta): t_0 = 2.0 + (beta + alpha) tmp = 0 if beta <= 4.9e+14: tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))) else: tmp = ((1.0 + alpha) / t_0) / (1.0 + t_0) return tmp
function code(alpha, beta) t_0 = Float64(2.0 + Float64(beta + alpha)) tmp = 0.0 if (beta <= 4.9e+14) tmp = Float64(Float64(beta + 1.0) / Float64(Float64(beta + 2.0) * Float64(6.0 + Float64(beta * Float64(beta + 5.0))))); else tmp = Float64(Float64(Float64(1.0 + alpha) / t_0) / Float64(1.0 + t_0)); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = 2.0 + (beta + alpha); tmp = 0.0; if (beta <= 4.9e+14) tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))); else tmp = ((1.0 + alpha) / t_0) / (1.0 + t_0); end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 4.9e+14], N[(N[(beta + 1.0), $MachinePrecision] / N[(N[(beta + 2.0), $MachinePrecision] * N[(6.0 + N[(beta * N[(beta + 5.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 2 + \left(\beta + \alpha\right)\\
\mathbf{if}\;\beta \leq 4.9 \cdot 10^{+14}:\\
\;\;\;\;\frac{\beta + 1}{\left(\beta + 2\right) \cdot \left(6 + \beta \cdot \left(\beta + 5\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{t_0}}{1 + t_0}\\
\end{array}
\end{array}
if beta < 4.9e14Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/93.6%
Simplified93.6%
Taylor expanded in beta around 0 93.6%
Taylor expanded in alpha around 0 69.0%
unpow269.0%
distribute-rgt-out69.0%
Simplified69.0%
if 4.9e14 < beta Initial program 81.9%
div-inv81.8%
+-commutative81.8%
associate-+l+81.8%
*-commutative81.8%
metadata-eval81.8%
+-commutative81.8%
metadata-eval81.8%
+-commutative81.8%
Applied egg-rr81.8%
associate-*l/81.8%
associate-*r/81.9%
*-rgt-identity81.9%
associate-+r+81.9%
*-rgt-identity81.9%
+-commutative81.9%
distribute-rgt1-in81.9%
distribute-lft-in81.9%
+-commutative81.9%
+-commutative81.9%
*-commutative81.9%
+-commutative81.9%
+-commutative81.9%
associate-*r/99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
Taylor expanded in beta around inf 80.7%
Final simplification72.6%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.65) (+ 0.08333333333333333 (* beta -0.027777777777777776)) (* (+ 1.0 alpha) (/ (+ 1.0 (/ (- -1.0 alpha) beta)) (* beta beta)))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.65) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta));
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.65d0) then
tmp = 0.08333333333333333d0 + (beta * (-0.027777777777777776d0))
else
tmp = (1.0d0 + alpha) * ((1.0d0 + (((-1.0d0) - alpha) / beta)) / (beta * beta))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.65) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.65: tmp = 0.08333333333333333 + (beta * -0.027777777777777776) else: tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta)) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.65) tmp = Float64(0.08333333333333333 + Float64(beta * -0.027777777777777776)); else tmp = Float64(Float64(1.0 + alpha) * Float64(Float64(1.0 + Float64(Float64(-1.0 - alpha) / beta)) / Float64(beta * beta))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.65) tmp = 0.08333333333333333 + (beta * -0.027777777777777776); else tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta)); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.65], N[(0.08333333333333333 + N[(beta * -0.027777777777777776), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + alpha), $MachinePrecision] * N[(N[(1.0 + N[(N[(-1.0 - alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.65:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\left(1 + \alpha\right) \cdot \frac{1 + \frac{-1 - \alpha}{\beta}}{\beta \cdot \beta}\\
\end{array}
\end{array}
if beta < 2.64999999999999991Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/94.0%
Simplified94.0%
Taylor expanded in beta around 0 94.0%
Taylor expanded in alpha around 0 69.0%
unpow269.0%
distribute-rgt-out69.0%
Simplified69.0%
Taylor expanded in beta around 0 68.1%
*-commutative68.1%
Simplified68.1%
if 2.64999999999999991 < beta Initial program 82.8%
associate-/l/79.0%
associate-+l+79.0%
+-commutative79.0%
associate-+r+79.0%
associate-+l+79.0%
distribute-rgt1-in79.0%
*-rgt-identity79.0%
distribute-lft-out79.0%
+-commutative79.0%
associate-*l/91.1%
*-commutative91.1%
associate-*r/87.2%
Simplified87.2%
Taylor expanded in beta around inf 79.4%
mul-1-neg79.4%
unsub-neg79.4%
Simplified79.4%
Taylor expanded in beta around inf 72.4%
unpow272.4%
Simplified72.4%
Final simplification69.4%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2e+25) (/ (+ beta 1.0) (* (+ beta 2.0) (+ 6.0 (* beta (+ beta 5.0))))) (* (+ 1.0 alpha) (/ (+ 1.0 (/ (- -1.0 alpha) beta)) (* beta beta)))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2e+25) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta));
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2d+25) then
tmp = (beta + 1.0d0) / ((beta + 2.0d0) * (6.0d0 + (beta * (beta + 5.0d0))))
else
tmp = (1.0d0 + alpha) * ((1.0d0 + (((-1.0d0) - alpha) / beta)) / (beta * beta))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2e+25) {
tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0))));
} else {
tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2e+25: tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))) else: tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta)) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2e+25) tmp = Float64(Float64(beta + 1.0) / Float64(Float64(beta + 2.0) * Float64(6.0 + Float64(beta * Float64(beta + 5.0))))); else tmp = Float64(Float64(1.0 + alpha) * Float64(Float64(1.0 + Float64(Float64(-1.0 - alpha) / beta)) / Float64(beta * beta))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2e+25) tmp = (beta + 1.0) / ((beta + 2.0) * (6.0 + (beta * (beta + 5.0)))); else tmp = (1.0 + alpha) * ((1.0 + ((-1.0 - alpha) / beta)) / (beta * beta)); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2e+25], N[(N[(beta + 1.0), $MachinePrecision] / N[(N[(beta + 2.0), $MachinePrecision] * N[(6.0 + N[(beta * N[(beta + 5.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + alpha), $MachinePrecision] * N[(N[(1.0 + N[(N[(-1.0 - alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2 \cdot 10^{+25}:\\
\;\;\;\;\frac{\beta + 1}{\left(\beta + 2\right) \cdot \left(6 + \beta \cdot \left(\beta + 5\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(1 + \alpha\right) \cdot \frac{1 + \frac{-1 - \alpha}{\beta}}{\beta \cdot \beta}\\
\end{array}
\end{array}
if beta < 2.00000000000000018e25Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/93.2%
Simplified93.2%
Taylor expanded in beta around 0 93.2%
Taylor expanded in alpha around 0 68.9%
unpow268.9%
distribute-rgt-out68.9%
Simplified68.9%
if 2.00000000000000018e25 < beta Initial program 81.4%
associate-/l/77.3%
associate-+l+77.3%
+-commutative77.3%
associate-+r+77.3%
associate-+l+77.3%
distribute-rgt1-in77.3%
*-rgt-identity77.3%
distribute-lft-out77.3%
+-commutative77.3%
associate-*l/90.4%
*-commutative90.4%
associate-*r/88.7%
Simplified88.7%
Taylor expanded in beta around inf 81.9%
mul-1-neg81.9%
unsub-neg81.9%
Simplified81.9%
Taylor expanded in beta around inf 75.0%
unpow275.0%
Simplified75.0%
Final simplification70.7%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.85) (+ 0.08333333333333333 (* beta -0.027777777777777776)) (* (+ 1.0 alpha) (/ (- 1.0 (/ alpha beta)) (* beta beta)))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.85) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = (1.0 + alpha) * ((1.0 - (alpha / beta)) / (beta * beta));
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.85d0) then
tmp = 0.08333333333333333d0 + (beta * (-0.027777777777777776d0))
else
tmp = (1.0d0 + alpha) * ((1.0d0 - (alpha / beta)) / (beta * beta))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.85) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = (1.0 + alpha) * ((1.0 - (alpha / beta)) / (beta * beta));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.85: tmp = 0.08333333333333333 + (beta * -0.027777777777777776) else: tmp = (1.0 + alpha) * ((1.0 - (alpha / beta)) / (beta * beta)) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.85) tmp = Float64(0.08333333333333333 + Float64(beta * -0.027777777777777776)); else tmp = Float64(Float64(1.0 + alpha) * Float64(Float64(1.0 - Float64(alpha / beta)) / Float64(beta * beta))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.85) tmp = 0.08333333333333333 + (beta * -0.027777777777777776); else tmp = (1.0 + alpha) * ((1.0 - (alpha / beta)) / (beta * beta)); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.85], N[(0.08333333333333333 + N[(beta * -0.027777777777777776), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + alpha), $MachinePrecision] * N[(N[(1.0 - N[(alpha / beta), $MachinePrecision]), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.85:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\left(1 + \alpha\right) \cdot \frac{1 - \frac{\alpha}{\beta}}{\beta \cdot \beta}\\
\end{array}
\end{array}
if beta < 2.85000000000000009Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/93.5%
Simplified93.5%
Taylor expanded in beta around 0 93.5%
Taylor expanded in alpha around 0 68.6%
unpow268.6%
distribute-rgt-out68.6%
Simplified68.6%
Taylor expanded in beta around 0 67.7%
*-commutative67.7%
Simplified67.7%
if 2.85000000000000009 < beta Initial program 82.5%
associate-/l/78.7%
associate-+l+78.7%
+-commutative78.7%
associate-+r+78.7%
associate-+l+78.7%
distribute-rgt1-in78.7%
*-rgt-identity78.7%
distribute-lft-out78.7%
+-commutative78.7%
associate-*l/91.0%
*-commutative91.0%
associate-*r/88.2%
Simplified88.2%
Taylor expanded in beta around inf 80.4%
mul-1-neg80.4%
unsub-neg80.4%
Simplified80.4%
Taylor expanded in alpha around inf 79.9%
Taylor expanded in beta around inf 73.3%
unpow273.3%
Simplified73.3%
Final simplification69.4%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.8) (+ 0.08333333333333333 (* beta -0.027777777777777776)) (/ (+ 1.0 alpha) (* beta beta))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = (1.0 + alpha) / (beta * beta);
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.8d0) then
tmp = 0.08333333333333333d0 + (beta * (-0.027777777777777776d0))
else
tmp = (1.0d0 + alpha) / (beta * beta)
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = (1.0 + alpha) / (beta * beta);
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.8: tmp = 0.08333333333333333 + (beta * -0.027777777777777776) else: tmp = (1.0 + alpha) / (beta * beta) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.8) tmp = Float64(0.08333333333333333 + Float64(beta * -0.027777777777777776)); else tmp = Float64(Float64(1.0 + alpha) / Float64(beta * beta)); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.8) tmp = 0.08333333333333333 + (beta * -0.027777777777777776); else tmp = (1.0 + alpha) / (beta * beta); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.8], N[(0.08333333333333333 + N[(beta * -0.027777777777777776), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + alpha), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\frac{1 + \alpha}{\beta \cdot \beta}\\
\end{array}
\end{array}
if beta < 2.7999999999999998Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/94.0%
Simplified94.0%
Taylor expanded in beta around 0 94.0%
Taylor expanded in alpha around 0 69.0%
unpow269.0%
distribute-rgt-out69.0%
Simplified69.0%
Taylor expanded in beta around 0 68.1%
*-commutative68.1%
Simplified68.1%
if 2.7999999999999998 < beta Initial program 82.8%
associate-/l/79.0%
associate-+l+79.0%
+-commutative79.0%
associate-+r+79.0%
associate-+l+79.0%
distribute-rgt1-in79.0%
*-rgt-identity79.0%
distribute-lft-out79.0%
+-commutative79.0%
associate-*l/91.1%
*-commutative91.1%
associate-*r/87.2%
Simplified87.2%
Taylor expanded in beta around inf 72.8%
unpow272.8%
Simplified72.8%
Final simplification69.6%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.8) (+ 0.08333333333333333 (* beta -0.027777777777777776)) (/ 1.0 (* beta beta))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = 1.0 / (beta * beta);
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.8d0) then
tmp = 0.08333333333333333d0 + (beta * (-0.027777777777777776d0))
else
tmp = 1.0d0 / (beta * beta)
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = 1.0 / (beta * beta);
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.8: tmp = 0.08333333333333333 + (beta * -0.027777777777777776) else: tmp = 1.0 / (beta * beta) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.8) tmp = Float64(0.08333333333333333 + Float64(beta * -0.027777777777777776)); else tmp = Float64(1.0 / Float64(beta * beta)); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.8) tmp = 0.08333333333333333 + (beta * -0.027777777777777776); else tmp = 1.0 / (beta * beta); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.8], N[(0.08333333333333333 + N[(beta * -0.027777777777777776), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(beta * beta), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\beta \cdot \beta}\\
\end{array}
\end{array}
if beta < 2.7999999999999998Initial program 99.9%
associate-/l/99.7%
associate-+l+99.7%
+-commutative99.7%
associate-+r+99.7%
associate-+l+99.7%
distribute-rgt1-in99.7%
*-rgt-identity99.7%
distribute-lft-out99.7%
+-commutative99.7%
associate-*l/99.7%
*-commutative99.7%
associate-*r/94.0%
Simplified94.0%
Taylor expanded in beta around 0 94.0%
Taylor expanded in alpha around 0 69.0%
unpow269.0%
distribute-rgt-out69.0%
Simplified69.0%
Taylor expanded in beta around 0 68.1%
*-commutative68.1%
Simplified68.1%
if 2.7999999999999998 < beta Initial program 82.8%
associate-/l/79.0%
associate-+l+79.0%
+-commutative79.0%
associate-+r+79.0%
associate-+l+79.0%
distribute-rgt1-in79.0%
*-rgt-identity79.0%
distribute-lft-out79.0%
+-commutative79.0%
associate-*l/91.1%
*-commutative91.1%
associate-*r/87.2%
Simplified87.2%
Taylor expanded in beta around inf 72.8%
unpow272.8%
Simplified72.8%
Taylor expanded in alpha around 0 71.7%
unpow271.7%
Simplified71.7%
Final simplification69.2%
(FPCore (alpha beta) :precision binary64 0.08333333333333333)
double code(double alpha, double beta) {
return 0.08333333333333333;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = 0.08333333333333333d0
end function
public static double code(double alpha, double beta) {
return 0.08333333333333333;
}
def code(alpha, beta): return 0.08333333333333333
function code(alpha, beta) return 0.08333333333333333 end
function tmp = code(alpha, beta) tmp = 0.08333333333333333; end
code[alpha_, beta_] := 0.08333333333333333
\begin{array}{l}
\\
0.08333333333333333
\end{array}
Initial program 94.4%
associate-/l/93.1%
associate-+l+93.1%
+-commutative93.1%
associate-+r+93.1%
associate-+l+93.1%
distribute-rgt1-in93.2%
*-rgt-identity93.2%
distribute-lft-out93.2%
+-commutative93.2%
associate-*l/97.0%
*-commutative97.0%
associate-*r/91.8%
Simplified91.8%
Taylor expanded in beta around 0 91.9%
Taylor expanded in alpha around 0 67.9%
unpow267.9%
distribute-rgt-out67.9%
Simplified67.9%
Taylor expanded in beta around 0 47.2%
Final simplification47.2%
herbie shell --seed 2023258
(FPCore (alpha beta)
:name "Octave 3.8, jcobi/3"
:precision binary64
:pre (and (> alpha -1.0) (> beta -1.0))
(/ (/ (/ (+ (+ (+ alpha beta) (* beta alpha)) 1.0) (+ (+ alpha beta) (* 2.0 1.0))) (+ (+ alpha beta) (* 2.0 1.0))) (+ (+ (+ alpha beta) (* 2.0 1.0)) 1.0)))