
(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 16 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}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ 2.0 (+ beta alpha))))
(/
(/ 1.0 t_0)
(* (/ t_0 (+ 1.0 alpha)) (/ (+ alpha (+ beta 3.0)) (+ 1.0 beta))))))assert(alpha < beta);
double code(double alpha, double beta) {
double t_0 = 2.0 + (beta + alpha);
return (1.0 / t_0) / ((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta)));
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
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 = (1.0d0 / t_0) / ((t_0 / (1.0d0 + alpha)) * ((alpha + (beta + 3.0d0)) / (1.0d0 + beta)))
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double t_0 = 2.0 + (beta + alpha);
return (1.0 / t_0) / ((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta)));
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): t_0 = 2.0 + (beta + alpha) return (1.0 / t_0) / ((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta)))
alpha, beta = sort([alpha, beta]) function code(alpha, beta) t_0 = Float64(2.0 + Float64(beta + alpha)) return Float64(Float64(1.0 / t_0) / Float64(Float64(t_0 / Float64(1.0 + alpha)) * Float64(Float64(alpha + Float64(beta + 3.0)) / Float64(1.0 + beta)))) end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp = code(alpha, beta)
t_0 = 2.0 + (beta + alpha);
tmp = (1.0 / t_0) / ((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta)));
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_] := Block[{t$95$0 = N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, N[(N[(1.0 / t$95$0), $MachinePrecision] / N[(N[(t$95$0 / N[(1.0 + alpha), $MachinePrecision]), $MachinePrecision] * N[(N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision] / N[(1.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := 2 + \left(\beta + \alpha\right)\\
\frac{\frac{1}{t\_0}}{\frac{t\_0}{1 + \alpha} \cdot \frac{\alpha + \left(\beta + 3\right)}{1 + \beta}}
\end{array}
\end{array}
Initial program 95.9%
associate-/l/94.0%
+-commutative94.0%
associate-+l+94.0%
*-commutative94.0%
+-commutative94.0%
metadata-eval94.0%
associate-+l+94.0%
metadata-eval94.0%
associate-+l+94.0%
+-commutative94.0%
associate-+l+94.0%
metadata-eval94.0%
+-commutative94.0%
metadata-eval94.0%
Simplified94.0%
clear-num94.0%
inv-pow94.0%
associate-+r+94.0%
associate-+r+94.0%
+-commutative94.0%
associate-+r+94.0%
+-commutative94.0%
distribute-rgt1-in94.0%
fma-define94.0%
associate-+r+94.0%
+-commutative94.0%
associate-+r+94.0%
Applied egg-rr94.0%
unpow-194.0%
associate-/r/94.0%
*-commutative94.0%
+-commutative94.0%
+-commutative94.0%
+-commutative94.0%
fma-undefine94.0%
+-commutative94.0%
*-commutative94.0%
+-commutative94.0%
associate-+r+94.0%
distribute-lft1-in94.0%
+-commutative94.0%
+-commutative94.0%
*-commutative94.0%
+-commutative94.0%
Simplified94.0%
inv-pow94.0%
*-commutative94.0%
+-commutative94.0%
+-commutative94.0%
unpow-prod-down94.0%
inv-pow94.0%
inv-pow94.0%
times-frac99.7%
+-commutative99.7%
+-commutative99.7%
Applied egg-rr99.7%
associate-*r/99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
add099.8%
*-rgt-identity99.8%
Applied egg-rr99.8%
add099.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
Final simplification99.8%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ alpha (+ 2.0 beta))) (t_1 (+ alpha (+ beta 3.0))))
(if (<= beta 3.8e+133)
(* (/ (+ 1.0 beta) t_1) (/ (+ 1.0 alpha) (* t_0 t_0)))
(/
(/ 1.0 beta)
(* (/ (+ 2.0 (+ beta alpha)) (+ 1.0 alpha)) (/ t_1 (+ 1.0 beta)))))))assert(alpha < beta);
double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
double t_1 = alpha + (beta + 3.0);
double tmp;
if (beta <= 3.8e+133) {
tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0));
} else {
tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * (t_1 / (1.0 + beta)));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
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 + (2.0d0 + beta)
t_1 = alpha + (beta + 3.0d0)
if (beta <= 3.8d+133) then
tmp = ((1.0d0 + beta) / t_1) * ((1.0d0 + alpha) / (t_0 * t_0))
else
tmp = (1.0d0 / beta) / (((2.0d0 + (beta + alpha)) / (1.0d0 + alpha)) * (t_1 / (1.0d0 + beta)))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
double t_1 = alpha + (beta + 3.0);
double tmp;
if (beta <= 3.8e+133) {
tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0));
} else {
tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * (t_1 / (1.0 + beta)));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): t_0 = alpha + (2.0 + beta) t_1 = alpha + (beta + 3.0) tmp = 0 if beta <= 3.8e+133: tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0)) else: tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * (t_1 / (1.0 + beta))) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) t_0 = Float64(alpha + Float64(2.0 + beta)) t_1 = Float64(alpha + Float64(beta + 3.0)) tmp = 0.0 if (beta <= 3.8e+133) tmp = Float64(Float64(Float64(1.0 + beta) / t_1) * Float64(Float64(1.0 + alpha) / Float64(t_0 * t_0))); else tmp = Float64(Float64(1.0 / beta) / Float64(Float64(Float64(2.0 + Float64(beta + alpha)) / Float64(1.0 + alpha)) * Float64(t_1 / Float64(1.0 + beta)))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
t_0 = alpha + (2.0 + beta);
t_1 = alpha + (beta + 3.0);
tmp = 0.0;
if (beta <= 3.8e+133)
tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0));
else
tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * (t_1 / (1.0 + beta)));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 3.8e+133], N[(N[(N[(1.0 + beta), $MachinePrecision] / t$95$1), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / beta), $MachinePrecision] / N[(N[(N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision] / N[(1.0 + alpha), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 / N[(1.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \alpha + \left(2 + \beta\right)\\
t_1 := \alpha + \left(\beta + 3\right)\\
\mathbf{if}\;\beta \leq 3.8 \cdot 10^{+133}:\\
\;\;\;\;\frac{1 + \beta}{t\_1} \cdot \frac{1 + \alpha}{t\_0 \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{\beta}}{\frac{2 + \left(\beta + \alpha\right)}{1 + \alpha} \cdot \frac{t\_1}{1 + \beta}}\\
\end{array}
\end{array}
if beta < 3.8000000000000002e133Initial program 98.4%
Simplified98.3%
if 3.8000000000000002e133 < beta Initial program 83.5%
associate-/l/79.3%
+-commutative79.3%
associate-+l+79.3%
*-commutative79.3%
+-commutative79.3%
metadata-eval79.3%
associate-+l+79.3%
metadata-eval79.3%
associate-+l+79.3%
+-commutative79.3%
associate-+l+79.3%
metadata-eval79.3%
+-commutative79.3%
metadata-eval79.3%
Simplified79.3%
clear-num79.3%
inv-pow79.3%
associate-+r+79.3%
associate-+r+79.3%
+-commutative79.3%
associate-+r+79.3%
+-commutative79.3%
distribute-rgt1-in79.3%
fma-define79.3%
associate-+r+79.3%
+-commutative79.3%
associate-+r+79.3%
Applied egg-rr79.3%
unpow-179.3%
associate-/r/79.4%
*-commutative79.4%
+-commutative79.4%
+-commutative79.4%
+-commutative79.4%
fma-undefine79.4%
+-commutative79.4%
*-commutative79.4%
+-commutative79.4%
associate-+r+79.4%
distribute-lft1-in79.4%
+-commutative79.4%
+-commutative79.4%
*-commutative79.4%
+-commutative79.4%
Simplified79.4%
inv-pow79.4%
*-commutative79.4%
+-commutative79.4%
+-commutative79.4%
unpow-prod-down79.4%
inv-pow79.4%
inv-pow79.4%
times-frac99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
associate-*r/99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
add099.8%
*-rgt-identity99.8%
Applied egg-rr99.8%
add099.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
Taylor expanded in beta around inf 92.4%
Final simplification97.3%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ alpha (+ 2.0 beta))) (t_1 (+ alpha (+ beta 3.0))))
(if (<= beta 3.8e+133)
(* (/ (+ 1.0 beta) t_1) (/ (+ 1.0 alpha) (* t_0 t_0)))
(/ (/ 1.0 t_0) (* (/ t_1 (+ 1.0 beta)) (/ beta (+ 1.0 alpha)))))))assert(alpha < beta);
double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
double t_1 = alpha + (beta + 3.0);
double tmp;
if (beta <= 3.8e+133) {
tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0));
} else {
tmp = (1.0 / t_0) / ((t_1 / (1.0 + beta)) * (beta / (1.0 + alpha)));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
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 + (2.0d0 + beta)
t_1 = alpha + (beta + 3.0d0)
if (beta <= 3.8d+133) then
tmp = ((1.0d0 + beta) / t_1) * ((1.0d0 + alpha) / (t_0 * t_0))
else
tmp = (1.0d0 / t_0) / ((t_1 / (1.0d0 + beta)) * (beta / (1.0d0 + alpha)))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
double t_1 = alpha + (beta + 3.0);
double tmp;
if (beta <= 3.8e+133) {
tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0));
} else {
tmp = (1.0 / t_0) / ((t_1 / (1.0 + beta)) * (beta / (1.0 + alpha)));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): t_0 = alpha + (2.0 + beta) t_1 = alpha + (beta + 3.0) tmp = 0 if beta <= 3.8e+133: tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0)) else: tmp = (1.0 / t_0) / ((t_1 / (1.0 + beta)) * (beta / (1.0 + alpha))) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) t_0 = Float64(alpha + Float64(2.0 + beta)) t_1 = Float64(alpha + Float64(beta + 3.0)) tmp = 0.0 if (beta <= 3.8e+133) tmp = Float64(Float64(Float64(1.0 + beta) / t_1) * Float64(Float64(1.0 + alpha) / Float64(t_0 * t_0))); else tmp = Float64(Float64(1.0 / t_0) / Float64(Float64(t_1 / Float64(1.0 + beta)) * Float64(beta / Float64(1.0 + alpha)))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
t_0 = alpha + (2.0 + beta);
t_1 = alpha + (beta + 3.0);
tmp = 0.0;
if (beta <= 3.8e+133)
tmp = ((1.0 + beta) / t_1) * ((1.0 + alpha) / (t_0 * t_0));
else
tmp = (1.0 / t_0) / ((t_1 / (1.0 + beta)) * (beta / (1.0 + alpha)));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 3.8e+133], N[(N[(N[(1.0 + beta), $MachinePrecision] / t$95$1), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / t$95$0), $MachinePrecision] / N[(N[(t$95$1 / N[(1.0 + beta), $MachinePrecision]), $MachinePrecision] * N[(beta / N[(1.0 + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \alpha + \left(2 + \beta\right)\\
t_1 := \alpha + \left(\beta + 3\right)\\
\mathbf{if}\;\beta \leq 3.8 \cdot 10^{+133}:\\
\;\;\;\;\frac{1 + \beta}{t\_1} \cdot \frac{1 + \alpha}{t\_0 \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{t\_0}}{\frac{t\_1}{1 + \beta} \cdot \frac{\beta}{1 + \alpha}}\\
\end{array}
\end{array}
if beta < 3.8000000000000002e133Initial program 98.4%
Simplified98.3%
if 3.8000000000000002e133 < beta Initial program 83.5%
associate-/l/79.3%
+-commutative79.3%
associate-+l+79.3%
*-commutative79.3%
+-commutative79.3%
metadata-eval79.3%
associate-+l+79.3%
metadata-eval79.3%
associate-+l+79.3%
+-commutative79.3%
associate-+l+79.3%
metadata-eval79.3%
+-commutative79.3%
metadata-eval79.3%
Simplified79.3%
clear-num79.3%
inv-pow79.3%
associate-+r+79.3%
associate-+r+79.3%
+-commutative79.3%
associate-+r+79.3%
+-commutative79.3%
distribute-rgt1-in79.3%
fma-define79.3%
associate-+r+79.3%
+-commutative79.3%
associate-+r+79.3%
Applied egg-rr79.3%
unpow-179.3%
associate-/r/79.4%
*-commutative79.4%
+-commutative79.4%
+-commutative79.4%
+-commutative79.4%
fma-undefine79.4%
+-commutative79.4%
*-commutative79.4%
+-commutative79.4%
associate-+r+79.4%
distribute-lft1-in79.4%
+-commutative79.4%
+-commutative79.4%
*-commutative79.4%
+-commutative79.4%
Simplified79.4%
inv-pow79.4%
*-commutative79.4%
+-commutative79.4%
+-commutative79.4%
unpow-prod-down79.4%
inv-pow79.4%
inv-pow79.4%
times-frac99.8%
+-commutative99.8%
+-commutative99.8%
Applied egg-rr99.8%
associate-*r/99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
Taylor expanded in beta around inf 92.4%
Final simplification97.3%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1e+36)
(/ (/ (+ 1.0 beta) (+ 2.0 beta)) (* (+ 2.0 beta) (+ 3.0 (+ beta alpha))))
(/
(/ 1.0 beta)
(*
(/ (+ 2.0 (+ beta alpha)) (+ 1.0 alpha))
(/ (+ alpha (+ beta 3.0)) (+ 1.0 beta))))))assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 1e+36) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha)));
} else {
tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta)));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 1d+36) then
tmp = ((1.0d0 + beta) / (2.0d0 + beta)) / ((2.0d0 + beta) * (3.0d0 + (beta + alpha)))
else
tmp = (1.0d0 / beta) / (((2.0d0 + (beta + alpha)) / (1.0d0 + alpha)) * ((alpha + (beta + 3.0d0)) / (1.0d0 + beta)))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1e+36) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha)));
} else {
tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta)));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 1e+36: tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha))) else: tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta))) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 1e+36) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(2.0 + beta)) / Float64(Float64(2.0 + beta) * Float64(3.0 + Float64(beta + alpha)))); else tmp = Float64(Float64(1.0 / beta) / Float64(Float64(Float64(2.0 + Float64(beta + alpha)) / Float64(1.0 + alpha)) * Float64(Float64(alpha + Float64(beta + 3.0)) / Float64(1.0 + beta)))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 1e+36)
tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha)));
else
tmp = (1.0 / beta) / (((2.0 + (beta + alpha)) / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta)));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 1e+36], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision] / N[(N[(2.0 + beta), $MachinePrecision] * N[(3.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / beta), $MachinePrecision] / N[(N[(N[(2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision] / N[(1.0 + alpha), $MachinePrecision]), $MachinePrecision] * N[(N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision] / N[(1.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 10^{+36}:\\
\;\;\;\;\frac{\frac{1 + \beta}{2 + \beta}}{\left(2 + \beta\right) \cdot \left(3 + \left(\beta + \alpha\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{\beta}}{\frac{2 + \left(\beta + \alpha\right)}{1 + \alpha} \cdot \frac{\alpha + \left(\beta + 3\right)}{1 + \beta}}\\
\end{array}
\end{array}
if beta < 1.00000000000000004e36Initial program 99.7%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.2%
Taylor expanded in alpha around 0 66.3%
if 1.00000000000000004e36 < beta Initial program 86.7%
associate-/l/80.1%
+-commutative80.1%
associate-+l+80.1%
*-commutative80.1%
+-commutative80.1%
metadata-eval80.1%
associate-+l+80.1%
metadata-eval80.1%
associate-+l+80.1%
+-commutative80.1%
associate-+l+80.1%
metadata-eval80.1%
+-commutative80.1%
metadata-eval80.1%
Simplified80.1%
clear-num80.1%
inv-pow80.1%
associate-+r+80.1%
associate-+r+80.1%
+-commutative80.1%
associate-+r+80.1%
+-commutative80.1%
distribute-rgt1-in80.1%
fma-define80.1%
associate-+r+80.1%
+-commutative80.1%
associate-+r+80.1%
Applied egg-rr80.1%
unpow-180.1%
associate-/r/80.1%
*-commutative80.1%
+-commutative80.1%
+-commutative80.1%
+-commutative80.1%
fma-undefine80.1%
+-commutative80.1%
*-commutative80.1%
+-commutative80.1%
associate-+r+80.1%
distribute-lft1-in80.1%
+-commutative80.1%
+-commutative80.1%
*-commutative80.1%
+-commutative80.1%
Simplified80.1%
inv-pow80.1%
*-commutative80.1%
+-commutative80.1%
+-commutative80.1%
unpow-prod-down80.1%
inv-pow80.1%
inv-pow80.1%
times-frac99.7%
+-commutative99.7%
+-commutative99.7%
Applied egg-rr99.7%
associate-*r/99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
add099.8%
*-rgt-identity99.8%
Applied egg-rr99.8%
add099.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
Taylor expanded in beta around inf 84.6%
Final simplification71.7%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ alpha (+ 2.0 beta))))
(/
1.0
(*
(* (/ t_0 (+ 1.0 alpha)) (/ (+ alpha (+ beta 3.0)) (+ 1.0 beta)))
t_0))))assert(alpha < beta);
double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
return 1.0 / (((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta))) * t_0);
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: t_0
t_0 = alpha + (2.0d0 + beta)
code = 1.0d0 / (((t_0 / (1.0d0 + alpha)) * ((alpha + (beta + 3.0d0)) / (1.0d0 + beta))) * t_0)
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
return 1.0 / (((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta))) * t_0);
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): t_0 = alpha + (2.0 + beta) return 1.0 / (((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta))) * t_0)
alpha, beta = sort([alpha, beta]) function code(alpha, beta) t_0 = Float64(alpha + Float64(2.0 + beta)) return Float64(1.0 / Float64(Float64(Float64(t_0 / Float64(1.0 + alpha)) * Float64(Float64(alpha + Float64(beta + 3.0)) / Float64(1.0 + beta))) * t_0)) end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp = code(alpha, beta)
t_0 = alpha + (2.0 + beta);
tmp = 1.0 / (((t_0 / (1.0 + alpha)) * ((alpha + (beta + 3.0)) / (1.0 + beta))) * t_0);
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(1.0 / N[(N[(N[(t$95$0 / N[(1.0 + alpha), $MachinePrecision]), $MachinePrecision] * N[(N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision] / N[(1.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \alpha + \left(2 + \beta\right)\\
\frac{1}{\left(\frac{t\_0}{1 + \alpha} \cdot \frac{\alpha + \left(\beta + 3\right)}{1 + \beta}\right) \cdot t\_0}
\end{array}
\end{array}
Initial program 95.9%
associate-/l/94.0%
+-commutative94.0%
associate-+l+94.0%
*-commutative94.0%
+-commutative94.0%
metadata-eval94.0%
associate-+l+94.0%
metadata-eval94.0%
associate-+l+94.0%
+-commutative94.0%
associate-+l+94.0%
metadata-eval94.0%
+-commutative94.0%
metadata-eval94.0%
Simplified94.0%
clear-num94.0%
inv-pow94.0%
associate-+r+94.0%
associate-+r+94.0%
+-commutative94.0%
associate-+r+94.0%
+-commutative94.0%
distribute-rgt1-in94.0%
fma-define94.0%
associate-+r+94.0%
+-commutative94.0%
associate-+r+94.0%
Applied egg-rr94.0%
unpow-194.0%
associate-/r/94.0%
*-commutative94.0%
+-commutative94.0%
+-commutative94.0%
+-commutative94.0%
fma-undefine94.0%
+-commutative94.0%
*-commutative94.0%
+-commutative94.0%
associate-+r+94.0%
distribute-lft1-in94.0%
+-commutative94.0%
+-commutative94.0%
*-commutative94.0%
+-commutative94.0%
Simplified94.0%
times-frac99.3%
+-commutative99.3%
+-commutative99.3%
Applied egg-rr99.3%
Final simplification99.3%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1.65e-50)
(/ (+ 1.0 alpha) (* (+ 2.0 alpha) (* (+ 2.0 alpha) (+ alpha 3.0))))
(if (<= beta 1.45e+36)
(/ (+ 1.0 beta) (* (+ 2.0 beta) (* (+ beta 3.0) (+ 2.0 beta))))
(/ (/ (+ 1.0 alpha) beta) (+ alpha (+ beta 3.0))))))assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.65e-50) {
tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0)));
} else if (beta <= 1.45e+36) {
tmp = (1.0 + beta) / ((2.0 + beta) * ((beta + 3.0) * (2.0 + beta)));
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 1.65d-50) then
tmp = (1.0d0 + alpha) / ((2.0d0 + alpha) * ((2.0d0 + alpha) * (alpha + 3.0d0)))
else if (beta <= 1.45d+36) then
tmp = (1.0d0 + beta) / ((2.0d0 + beta) * ((beta + 3.0d0) * (2.0d0 + beta)))
else
tmp = ((1.0d0 + alpha) / beta) / (alpha + (beta + 3.0d0))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.65e-50) {
tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0)));
} else if (beta <= 1.45e+36) {
tmp = (1.0 + beta) / ((2.0 + beta) * ((beta + 3.0) * (2.0 + beta)));
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 1.65e-50: tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0))) elif beta <= 1.45e+36: tmp = (1.0 + beta) / ((2.0 + beta) * ((beta + 3.0) * (2.0 + beta))) else: tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0)) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 1.65e-50) tmp = Float64(Float64(1.0 + alpha) / Float64(Float64(2.0 + alpha) * Float64(Float64(2.0 + alpha) * Float64(alpha + 3.0)))); elseif (beta <= 1.45e+36) tmp = Float64(Float64(1.0 + beta) / Float64(Float64(2.0 + beta) * Float64(Float64(beta + 3.0) * Float64(2.0 + beta)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / beta) / Float64(alpha + Float64(beta + 3.0))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 1.65e-50)
tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0)));
elseif (beta <= 1.45e+36)
tmp = (1.0 + beta) / ((2.0 + beta) * ((beta + 3.0) * (2.0 + beta)));
else
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 1.65e-50], N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(2.0 + alpha), $MachinePrecision] * N[(N[(2.0 + alpha), $MachinePrecision] * N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 1.45e+36], N[(N[(1.0 + beta), $MachinePrecision] / N[(N[(2.0 + beta), $MachinePrecision] * N[(N[(beta + 3.0), $MachinePrecision] * N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / beta), $MachinePrecision] / N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.65 \cdot 10^{-50}:\\
\;\;\;\;\frac{1 + \alpha}{\left(2 + \alpha\right) \cdot \left(\left(2 + \alpha\right) \cdot \left(\alpha + 3\right)\right)}\\
\mathbf{elif}\;\beta \leq 1.45 \cdot 10^{+36}:\\
\;\;\;\;\frac{1 + \beta}{\left(2 + \beta\right) \cdot \left(\left(\beta + 3\right) \cdot \left(2 + \beta\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\beta}}{\alpha + \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 1.6499999999999999e-50Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
associate-+r+99.8%
*-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
metadata-eval99.8%
metadata-eval99.8%
associate-+r+99.8%
distribute-lft-in99.9%
Applied egg-rr99.9%
Taylor expanded in beta around 0 90.3%
+-commutative90.3%
distribute-rgt-in90.2%
+-commutative90.2%
+-commutative90.2%
Simplified90.2%
if 1.6499999999999999e-50 < beta < 1.45e36Initial program 99.3%
associate-/l/99.6%
+-commutative99.6%
associate-+l+99.6%
*-commutative99.6%
+-commutative99.6%
metadata-eval99.6%
associate-+l+99.6%
metadata-eval99.6%
associate-+l+99.6%
+-commutative99.6%
associate-+l+99.6%
metadata-eval99.6%
+-commutative99.6%
metadata-eval99.6%
Simplified99.6%
Taylor expanded in alpha around 0 90.4%
add090.4%
associate-/l/90.4%
associate-+r+90.4%
*-commutative90.4%
associate-+r+90.4%
+-commutative90.4%
associate-+r+90.4%
+-commutative90.4%
Applied egg-rr90.4%
add090.4%
+-commutative90.4%
*-commutative90.4%
+-commutative90.4%
Simplified90.4%
Taylor expanded in alpha around 0 71.0%
+-commutative71.0%
+-commutative71.0%
Simplified71.0%
if 1.45e36 < beta Initial program 86.7%
Simplified89.6%
associate-*l/89.6%
+-commutative89.6%
div-inv89.6%
pow289.6%
associate-+r+89.6%
metadata-eval89.6%
pow-flip90.7%
metadata-eval90.7%
associate-+r+90.7%
metadata-eval90.7%
Applied egg-rr90.7%
Taylor expanded in beta around inf 84.1%
Final simplification86.9%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 (if (<= beta 5.5e+35) (/ (/ (+ 1.0 beta) (+ 2.0 beta)) (* (+ 2.0 beta) (+ 3.0 (+ beta alpha)))) (/ (/ (+ 1.0 alpha) beta) (+ alpha (+ beta 3.0)))))
assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 5.5e+35) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha)));
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 5.5d+35) then
tmp = ((1.0d0 + beta) / (2.0d0 + beta)) / ((2.0d0 + beta) * (3.0d0 + (beta + alpha)))
else
tmp = ((1.0d0 + alpha) / beta) / (alpha + (beta + 3.0d0))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 5.5e+35) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha)));
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 5.5e+35: tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha))) else: tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0)) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 5.5e+35) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(2.0 + beta)) / Float64(Float64(2.0 + beta) * Float64(3.0 + Float64(beta + alpha)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / beta) / Float64(alpha + Float64(beta + 3.0))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 5.5e+35)
tmp = ((1.0 + beta) / (2.0 + beta)) / ((2.0 + beta) * (3.0 + (beta + alpha)));
else
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 5.5e+35], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision] / N[(N[(2.0 + beta), $MachinePrecision] * N[(3.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / beta), $MachinePrecision] / N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 5.5 \cdot 10^{+35}:\\
\;\;\;\;\frac{\frac{1 + \beta}{2 + \beta}}{\left(2 + \beta\right) \cdot \left(3 + \left(\beta + \alpha\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\beta}}{\alpha + \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 5.50000000000000001e35Initial program 99.7%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.2%
Taylor expanded in alpha around 0 66.3%
if 5.50000000000000001e35 < beta Initial program 86.7%
Simplified89.6%
associate-*l/89.6%
+-commutative89.6%
div-inv89.6%
pow289.6%
associate-+r+89.6%
metadata-eval89.6%
pow-flip90.7%
metadata-eval90.7%
associate-+r+90.7%
metadata-eval90.7%
Applied egg-rr90.7%
Taylor expanded in beta around inf 84.1%
Final simplification71.5%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ alpha (+ beta 3.0))))
(if (<= beta 2.5)
(/ 0.25 (+ alpha 3.0))
(if (<= beta 3.8e+154)
(/ (+ 1.0 alpha) (* beta t_0))
(/ (/ alpha beta) t_0)))))assert(alpha < beta);
double code(double alpha, double beta) {
double t_0 = alpha + (beta + 3.0);
double tmp;
if (beta <= 2.5) {
tmp = 0.25 / (alpha + 3.0);
} else if (beta <= 3.8e+154) {
tmp = (1.0 + alpha) / (beta * t_0);
} else {
tmp = (alpha / beta) / t_0;
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
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 + 3.0d0)
if (beta <= 2.5d0) then
tmp = 0.25d0 / (alpha + 3.0d0)
else if (beta <= 3.8d+154) then
tmp = (1.0d0 + alpha) / (beta * t_0)
else
tmp = (alpha / beta) / t_0
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double t_0 = alpha + (beta + 3.0);
double tmp;
if (beta <= 2.5) {
tmp = 0.25 / (alpha + 3.0);
} else if (beta <= 3.8e+154) {
tmp = (1.0 + alpha) / (beta * t_0);
} else {
tmp = (alpha / beta) / t_0;
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): t_0 = alpha + (beta + 3.0) tmp = 0 if beta <= 2.5: tmp = 0.25 / (alpha + 3.0) elif beta <= 3.8e+154: tmp = (1.0 + alpha) / (beta * t_0) else: tmp = (alpha / beta) / t_0 return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) t_0 = Float64(alpha + Float64(beta + 3.0)) tmp = 0.0 if (beta <= 2.5) tmp = Float64(0.25 / Float64(alpha + 3.0)); elseif (beta <= 3.8e+154) tmp = Float64(Float64(1.0 + alpha) / Float64(beta * t_0)); else tmp = Float64(Float64(alpha / beta) / t_0); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
t_0 = alpha + (beta + 3.0);
tmp = 0.0;
if (beta <= 2.5)
tmp = 0.25 / (alpha + 3.0);
elseif (beta <= 3.8e+154)
tmp = (1.0 + alpha) / (beta * t_0);
else
tmp = (alpha / beta) / t_0;
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 2.5], N[(0.25 / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.8e+154], N[(N[(1.0 + alpha), $MachinePrecision] / N[(beta * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(alpha / beta), $MachinePrecision] / t$95$0), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \alpha + \left(\beta + 3\right)\\
\mathbf{if}\;\beta \leq 2.5:\\
\;\;\;\;\frac{0.25}{\alpha + 3}\\
\mathbf{elif}\;\beta \leq 3.8 \cdot 10^{+154}:\\
\;\;\;\;\frac{1 + \alpha}{\beta \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\alpha}{\beta}}{t\_0}\\
\end{array}
\end{array}
if beta < 2.5Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.0%
Taylor expanded in alpha around 0 65.3%
Taylor expanded in beta around 0 64.0%
+-commutative64.0%
Simplified64.0%
if 2.5 < beta < 3.7999999999999998e154Initial program 93.0%
Simplified92.6%
associate-*l/92.4%
+-commutative92.4%
div-inv92.4%
pow292.4%
associate-+r+92.4%
metadata-eval92.4%
pow-flip92.6%
metadata-eval92.6%
associate-+r+92.6%
metadata-eval92.6%
Applied egg-rr92.6%
Taylor expanded in beta around inf 75.7%
add075.7%
associate-/l/82.2%
Applied egg-rr82.2%
add082.2%
*-commutative82.2%
+-commutative82.2%
+-commutative82.2%
+-commutative82.2%
Simplified82.2%
if 3.7999999999999998e154 < beta Initial program 81.9%
Simplified88.3%
associate-*l/88.3%
+-commutative88.3%
div-inv88.3%
pow288.3%
associate-+r+88.3%
metadata-eval88.3%
pow-flip90.1%
metadata-eval90.1%
associate-+r+90.1%
metadata-eval90.1%
Applied egg-rr90.1%
Taylor expanded in beta around inf 91.5%
Taylor expanded in alpha around inf 89.6%
Final simplification71.0%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 (if (<= beta 2.6) (/ (+ 1.0 alpha) (* (+ 2.0 alpha) (* (+ 2.0 alpha) (+ alpha 3.0)))) (/ (/ (+ 1.0 alpha) beta) (+ alpha (+ beta 3.0)))))
assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.6) {
tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0)));
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.6d0) then
tmp = (1.0d0 + alpha) / ((2.0d0 + alpha) * ((2.0d0 + alpha) * (alpha + 3.0d0)))
else
tmp = ((1.0d0 + alpha) / beta) / (alpha + (beta + 3.0d0))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.6) {
tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0)));
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 2.6: tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0))) else: tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0)) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 2.6) tmp = Float64(Float64(1.0 + alpha) / Float64(Float64(2.0 + alpha) * Float64(Float64(2.0 + alpha) * Float64(alpha + 3.0)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / beta) / Float64(alpha + Float64(beta + 3.0))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 2.6)
tmp = (1.0 + alpha) / ((2.0 + alpha) * ((2.0 + alpha) * (alpha + 3.0)));
else
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 2.6], N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(2.0 + alpha), $MachinePrecision] * N[(N[(2.0 + alpha), $MachinePrecision] * N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / beta), $MachinePrecision] / N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.6:\\
\;\;\;\;\frac{1 + \alpha}{\left(2 + \alpha\right) \cdot \left(\left(2 + \alpha\right) \cdot \left(\alpha + 3\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\beta}}{\alpha + \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 2.60000000000000009Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
associate-+r+99.8%
*-commutative99.8%
associate-+r+99.8%
+-commutative99.8%
metadata-eval99.8%
metadata-eval99.8%
associate-+r+99.8%
distribute-lft-in99.8%
Applied egg-rr99.8%
Taylor expanded in beta around 0 90.3%
+-commutative90.3%
distribute-rgt-in90.3%
+-commutative90.3%
+-commutative90.3%
Simplified90.3%
if 2.60000000000000009 < beta Initial program 87.9%
Simplified90.6%
associate-*l/90.5%
+-commutative90.5%
div-inv90.5%
pow290.5%
associate-+r+90.5%
metadata-eval90.5%
pow-flip91.5%
metadata-eval91.5%
associate-+r+91.5%
metadata-eval91.5%
Applied egg-rr91.5%
Taylor expanded in beta around inf 82.9%
Final simplification87.9%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1.2)
(/ 0.25 (+ alpha 3.0))
(if (<= beta 8e+161)
(/ (/ 1.0 (+ beta 3.0)) (+ 2.0 beta))
(/ (/ alpha beta) (+ alpha (+ beta 3.0))))))assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.2) {
tmp = 0.25 / (alpha + 3.0);
} else if (beta <= 8e+161) {
tmp = (1.0 / (beta + 3.0)) / (2.0 + beta);
} else {
tmp = (alpha / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 1.2d0) then
tmp = 0.25d0 / (alpha + 3.0d0)
else if (beta <= 8d+161) then
tmp = (1.0d0 / (beta + 3.0d0)) / (2.0d0 + beta)
else
tmp = (alpha / beta) / (alpha + (beta + 3.0d0))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.2) {
tmp = 0.25 / (alpha + 3.0);
} else if (beta <= 8e+161) {
tmp = (1.0 / (beta + 3.0)) / (2.0 + beta);
} else {
tmp = (alpha / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 1.2: tmp = 0.25 / (alpha + 3.0) elif beta <= 8e+161: tmp = (1.0 / (beta + 3.0)) / (2.0 + beta) else: tmp = (alpha / beta) / (alpha + (beta + 3.0)) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 1.2) tmp = Float64(0.25 / Float64(alpha + 3.0)); elseif (beta <= 8e+161) tmp = Float64(Float64(1.0 / Float64(beta + 3.0)) / Float64(2.0 + beta)); else tmp = Float64(Float64(alpha / beta) / Float64(alpha + Float64(beta + 3.0))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 1.2)
tmp = 0.25 / (alpha + 3.0);
elseif (beta <= 8e+161)
tmp = (1.0 / (beta + 3.0)) / (2.0 + beta);
else
tmp = (alpha / beta) / (alpha + (beta + 3.0));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 1.2], N[(0.25 / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 8e+161], N[(N[(1.0 / N[(beta + 3.0), $MachinePrecision]), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision], N[(N[(alpha / beta), $MachinePrecision] / N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.2:\\
\;\;\;\;\frac{0.25}{\alpha + 3}\\
\mathbf{elif}\;\beta \leq 8 \cdot 10^{+161}:\\
\;\;\;\;\frac{\frac{1}{\beta + 3}}{2 + \beta}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\alpha}{\beta}}{\alpha + \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 1.19999999999999996Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.0%
Taylor expanded in alpha around 0 65.3%
Taylor expanded in beta around 0 64.0%
+-commutative64.0%
Simplified64.0%
if 1.19999999999999996 < beta < 8.0000000000000003e161Initial program 91.4%
associate-/l/83.3%
+-commutative83.3%
associate-+l+83.3%
*-commutative83.3%
+-commutative83.3%
metadata-eval83.3%
associate-+l+83.3%
metadata-eval83.3%
associate-+l+83.3%
+-commutative83.3%
associate-+l+83.3%
metadata-eval83.3%
+-commutative83.3%
metadata-eval83.3%
Simplified83.3%
Taylor expanded in alpha around 0 81.8%
Taylor expanded in alpha around 0 72.6%
+-commutative72.6%
Simplified72.6%
Taylor expanded in beta around inf 70.2%
add070.2%
*-commutative70.2%
Applied egg-rr70.2%
add070.2%
associate-/r*71.6%
+-commutative71.6%
Simplified71.6%
if 8.0000000000000003e161 < beta Initial program 83.1%
Simplified92.0%
associate-*l/92.0%
+-commutative92.0%
div-inv92.0%
pow292.0%
associate-+r+92.0%
metadata-eval92.0%
pow-flip92.0%
metadata-eval92.0%
associate-+r+92.0%
metadata-eval92.0%
Applied egg-rr92.0%
Taylor expanded in beta around inf 93.4%
Taylor expanded in alpha around inf 93.4%
Final simplification69.4%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 (if (<= beta 2.5) (/ 0.25 (+ alpha 3.0)) (/ (/ (+ 1.0 alpha) beta) (+ alpha (+ beta 3.0)))))
assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.5) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.5d0) then
tmp = 0.25d0 / (alpha + 3.0d0)
else
tmp = ((1.0d0 + alpha) / beta) / (alpha + (beta + 3.0d0))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.5) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 2.5: tmp = 0.25 / (alpha + 3.0) else: tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0)) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 2.5) tmp = Float64(0.25 / Float64(alpha + 3.0)); else tmp = Float64(Float64(Float64(1.0 + alpha) / beta) / Float64(alpha + Float64(beta + 3.0))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 2.5)
tmp = 0.25 / (alpha + 3.0);
else
tmp = ((1.0 + alpha) / beta) / (alpha + (beta + 3.0));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 2.5], N[(0.25 / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / beta), $MachinePrecision] / N[(alpha + N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.5:\\
\;\;\;\;\frac{0.25}{\alpha + 3}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\beta}}{\alpha + \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 2.5Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.0%
Taylor expanded in alpha around 0 65.3%
Taylor expanded in beta around 0 64.0%
+-commutative64.0%
Simplified64.0%
if 2.5 < beta Initial program 87.9%
Simplified90.6%
associate-*l/90.5%
+-commutative90.5%
div-inv90.5%
pow290.5%
associate-+r+90.5%
metadata-eval90.5%
pow-flip91.5%
metadata-eval91.5%
associate-+r+91.5%
metadata-eval91.5%
Applied egg-rr91.5%
Taylor expanded in beta around inf 82.9%
Final simplification70.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 (if (<= beta 1.1) (/ 0.25 (+ alpha 3.0)) (/ (/ 1.0 (+ beta 3.0)) (+ 2.0 beta))))
assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.1) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = (1.0 / (beta + 3.0)) / (2.0 + beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 1.1d0) then
tmp = 0.25d0 / (alpha + 3.0d0)
else
tmp = (1.0d0 / (beta + 3.0d0)) / (2.0d0 + beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.1) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = (1.0 / (beta + 3.0)) / (2.0 + beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 1.1: tmp = 0.25 / (alpha + 3.0) else: tmp = (1.0 / (beta + 3.0)) / (2.0 + beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 1.1) tmp = Float64(0.25 / Float64(alpha + 3.0)); else tmp = Float64(Float64(1.0 / Float64(beta + 3.0)) / Float64(2.0 + beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 1.1)
tmp = 0.25 / (alpha + 3.0);
else
tmp = (1.0 / (beta + 3.0)) / (2.0 + beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 1.1], N[(0.25 / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[(beta + 3.0), $MachinePrecision]), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.1:\\
\;\;\;\;\frac{0.25}{\alpha + 3}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{\beta + 3}}{2 + \beta}\\
\end{array}
\end{array}
if beta < 1.1000000000000001Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.0%
Taylor expanded in alpha around 0 65.3%
Taylor expanded in beta around 0 64.0%
+-commutative64.0%
Simplified64.0%
if 1.1000000000000001 < beta Initial program 87.9%
associate-/l/82.0%
+-commutative82.0%
associate-+l+82.0%
*-commutative82.0%
+-commutative82.0%
metadata-eval82.0%
associate-+l+82.0%
metadata-eval82.0%
associate-+l+82.0%
+-commutative82.0%
associate-+l+82.0%
metadata-eval82.0%
+-commutative82.0%
metadata-eval82.0%
Simplified82.0%
Taylor expanded in alpha around 0 86.1%
Taylor expanded in alpha around 0 80.8%
+-commutative80.8%
Simplified80.8%
Taylor expanded in beta around inf 79.4%
add079.4%
*-commutative79.4%
Applied egg-rr79.4%
add079.4%
associate-/r*80.2%
+-commutative80.2%
Simplified80.2%
Final simplification69.2%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 (if (<= beta 2.7) (/ 0.25 (+ alpha 3.0)) (/ 1.0 (* beta (+ beta 3.0)))))
assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.7) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = 1.0 / (beta * (beta + 3.0));
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.7d0) then
tmp = 0.25d0 / (alpha + 3.0d0)
else
tmp = 1.0d0 / (beta * (beta + 3.0d0))
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.7) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = 1.0 / (beta * (beta + 3.0));
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 2.7: tmp = 0.25 / (alpha + 3.0) else: tmp = 1.0 / (beta * (beta + 3.0)) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 2.7) tmp = Float64(0.25 / Float64(alpha + 3.0)); else tmp = Float64(1.0 / Float64(beta * Float64(beta + 3.0))); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 2.7)
tmp = 0.25 / (alpha + 3.0);
else
tmp = 1.0 / (beta * (beta + 3.0));
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 2.7], N[(0.25 / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(beta * N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.7:\\
\;\;\;\;\frac{0.25}{\alpha + 3}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\beta \cdot \left(\beta + 3\right)}\\
\end{array}
\end{array}
if beta < 2.7000000000000002Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.0%
Taylor expanded in alpha around 0 65.3%
Taylor expanded in beta around 0 64.0%
+-commutative64.0%
Simplified64.0%
if 2.7000000000000002 < beta Initial program 87.9%
Simplified90.6%
associate-*l/90.5%
+-commutative90.5%
div-inv90.5%
pow290.5%
associate-+r+90.5%
metadata-eval90.5%
pow-flip91.5%
metadata-eval91.5%
associate-+r+91.5%
metadata-eval91.5%
Applied egg-rr91.5%
Taylor expanded in beta around inf 82.9%
Taylor expanded in alpha around 0 79.3%
Final simplification68.9%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 (if (<= beta 2.4) (/ 0.25 (+ alpha 3.0)) (/ (/ 1.0 beta) (+ beta 3.0))))
assert(alpha < beta);
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.4) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = (1.0 / beta) / (beta + 3.0);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.4d0) then
tmp = 0.25d0 / (alpha + 3.0d0)
else
tmp = (1.0d0 / beta) / (beta + 3.0d0)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.4) {
tmp = 0.25 / (alpha + 3.0);
} else {
tmp = (1.0 / beta) / (beta + 3.0);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): tmp = 0 if beta <= 2.4: tmp = 0.25 / (alpha + 3.0) else: tmp = (1.0 / beta) / (beta + 3.0) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta) tmp = 0.0 if (beta <= 2.4) tmp = Float64(0.25 / Float64(alpha + 3.0)); else tmp = Float64(Float64(1.0 / beta) / Float64(beta + 3.0)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta)
tmp = 0.0;
if (beta <= 2.4)
tmp = 0.25 / (alpha + 3.0);
else
tmp = (1.0 / beta) / (beta + 3.0);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := If[LessEqual[beta, 2.4], N[(0.25 / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / beta), $MachinePrecision] / N[(beta + 3.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.4:\\
\;\;\;\;\frac{0.25}{\alpha + 3}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{\beta}}{\beta + 3}\\
\end{array}
\end{array}
if beta < 2.39999999999999991Initial program 99.8%
associate-/l/99.8%
+-commutative99.8%
associate-+l+99.8%
*-commutative99.8%
+-commutative99.8%
metadata-eval99.8%
associate-+l+99.8%
metadata-eval99.8%
associate-+l+99.8%
+-commutative99.8%
associate-+l+99.8%
metadata-eval99.8%
+-commutative99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in alpha around 0 84.0%
Taylor expanded in alpha around 0 65.3%
Taylor expanded in beta around 0 64.0%
+-commutative64.0%
Simplified64.0%
if 2.39999999999999991 < beta Initial program 87.9%
Simplified90.6%
associate-*l/90.5%
+-commutative90.5%
div-inv90.5%
pow290.5%
associate-+r+90.5%
metadata-eval90.5%
pow-flip91.5%
metadata-eval91.5%
associate-+r+91.5%
metadata-eval91.5%
Applied egg-rr91.5%
Taylor expanded in beta around inf 82.9%
Taylor expanded in alpha around 0 79.3%
associate-/r*80.1%
+-commutative80.1%
Simplified80.1%
Final simplification69.2%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 (/ 0.25 (+ alpha 3.0)))
assert(alpha < beta);
double code(double alpha, double beta) {
return 0.25 / (alpha + 3.0);
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = 0.25d0 / (alpha + 3.0d0)
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
return 0.25 / (alpha + 3.0);
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): return 0.25 / (alpha + 3.0)
alpha, beta = sort([alpha, beta]) function code(alpha, beta) return Float64(0.25 / Float64(alpha + 3.0)) end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp = code(alpha, beta)
tmp = 0.25 / (alpha + 3.0);
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := N[(0.25 / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\frac{0.25}{\alpha + 3}
\end{array}
Initial program 95.9%
associate-/l/94.0%
+-commutative94.0%
associate-+l+94.0%
*-commutative94.0%
+-commutative94.0%
metadata-eval94.0%
associate-+l+94.0%
metadata-eval94.0%
associate-+l+94.0%
+-commutative94.0%
associate-+l+94.0%
metadata-eval94.0%
+-commutative94.0%
metadata-eval94.0%
Simplified94.0%
Taylor expanded in alpha around 0 84.7%
Taylor expanded in alpha around 0 71.5%
Taylor expanded in beta around 0 44.9%
+-commutative44.9%
Simplified44.9%
Final simplification44.9%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta) :precision binary64 0.08333333333333333)
assert(alpha < beta);
double code(double alpha, double beta) {
return 0.08333333333333333;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = 0.08333333333333333d0
end function
assert alpha < beta;
public static double code(double alpha, double beta) {
return 0.08333333333333333;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta): return 0.08333333333333333
alpha, beta = sort([alpha, beta]) function code(alpha, beta) return 0.08333333333333333 end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp = code(alpha, beta)
tmp = 0.08333333333333333;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_] := 0.08333333333333333
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
0.08333333333333333
\end{array}
Initial program 95.9%
associate-/l/94.0%
+-commutative94.0%
associate-+l+94.0%
*-commutative94.0%
+-commutative94.0%
metadata-eval94.0%
associate-+l+94.0%
metadata-eval94.0%
associate-+l+94.0%
+-commutative94.0%
associate-+l+94.0%
metadata-eval94.0%
+-commutative94.0%
metadata-eval94.0%
Simplified94.0%
Taylor expanded in alpha around 0 84.7%
Taylor expanded in alpha around 0 68.7%
+-commutative68.7%
Simplified68.7%
Taylor expanded in beta around 0 42.9%
Final simplification42.9%
herbie shell --seed 2024034
(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)))