
(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 25 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 (+ alpha (+ 2.0 beta)))) (/ (/ (/ (+ 1.0 alpha) (/ t_0 (+ 1.0 beta))) t_0) (+ (+ alpha beta) 3.0))))
double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
return (((1.0 + alpha) / (t_0 / (1.0 + beta))) / t_0) / ((alpha + beta) + 3.0);
}
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 + alpha) / (t_0 / (1.0d0 + beta))) / t_0) / ((alpha + beta) + 3.0d0)
end function
public static double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
return (((1.0 + alpha) / (t_0 / (1.0 + beta))) / t_0) / ((alpha + beta) + 3.0);
}
def code(alpha, beta): t_0 = alpha + (2.0 + beta) return (((1.0 + alpha) / (t_0 / (1.0 + beta))) / t_0) / ((alpha + beta) + 3.0)
function code(alpha, beta) t_0 = Float64(alpha + Float64(2.0 + beta)) return Float64(Float64(Float64(Float64(1.0 + alpha) / Float64(t_0 / Float64(1.0 + beta))) / t_0) / Float64(Float64(alpha + beta) + 3.0)) end
function tmp = code(alpha, beta) t_0 = alpha + (2.0 + beta); tmp = (((1.0 + alpha) / (t_0 / (1.0 + beta))) / t_0) / ((alpha + beta) + 3.0); end
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(t$95$0 / N[(1.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(2 + \beta\right)\\
\frac{\frac{\frac{1 + \alpha}{\frac{t\_0}{1 + \beta}}}{t\_0}}{\left(\alpha + \beta\right) + 3}
\end{array}
\end{array}
Initial program 93.7%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8%
Applied egg-rr99.8%
/-lowering-/.f64N/A
Applied egg-rr99.9%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ alpha (+ 2.0 beta)))
(t_1 (+ 2.0 (+ alpha beta)))
(t_2 (+ (+ alpha beta) 3.0)))
(if (<= alpha -2e-15)
(/ (+ 1.0 alpha) (* t_1 (* t_2 t_1)))
(if (<= alpha 1.75)
(/ (/ (/ (+ 1.0 beta) (+ 2.0 beta)) t_0) t_2)
(/ (/ (/ alpha (/ t_0 (+ 1.0 beta))) t_0) t_2)))))
double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
double t_1 = 2.0 + (alpha + beta);
double t_2 = (alpha + beta) + 3.0;
double tmp;
if (alpha <= -2e-15) {
tmp = (1.0 + alpha) / (t_1 * (t_2 * t_1));
} else if (alpha <= 1.75) {
tmp = (((1.0 + beta) / (2.0 + beta)) / t_0) / t_2;
} else {
tmp = ((alpha / (t_0 / (1.0 + beta))) / t_0) / t_2;
}
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) :: t_2
real(8) :: tmp
t_0 = alpha + (2.0d0 + beta)
t_1 = 2.0d0 + (alpha + beta)
t_2 = (alpha + beta) + 3.0d0
if (alpha <= (-2d-15)) then
tmp = (1.0d0 + alpha) / (t_1 * (t_2 * t_1))
else if (alpha <= 1.75d0) then
tmp = (((1.0d0 + beta) / (2.0d0 + beta)) / t_0) / t_2
else
tmp = ((alpha / (t_0 / (1.0d0 + beta))) / t_0) / t_2
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
double t_1 = 2.0 + (alpha + beta);
double t_2 = (alpha + beta) + 3.0;
double tmp;
if (alpha <= -2e-15) {
tmp = (1.0 + alpha) / (t_1 * (t_2 * t_1));
} else if (alpha <= 1.75) {
tmp = (((1.0 + beta) / (2.0 + beta)) / t_0) / t_2;
} else {
tmp = ((alpha / (t_0 / (1.0 + beta))) / t_0) / t_2;
}
return tmp;
}
def code(alpha, beta): t_0 = alpha + (2.0 + beta) t_1 = 2.0 + (alpha + beta) t_2 = (alpha + beta) + 3.0 tmp = 0 if alpha <= -2e-15: tmp = (1.0 + alpha) / (t_1 * (t_2 * t_1)) elif alpha <= 1.75: tmp = (((1.0 + beta) / (2.0 + beta)) / t_0) / t_2 else: tmp = ((alpha / (t_0 / (1.0 + beta))) / t_0) / t_2 return tmp
function code(alpha, beta) t_0 = Float64(alpha + Float64(2.0 + beta)) t_1 = Float64(2.0 + Float64(alpha + beta)) t_2 = Float64(Float64(alpha + beta) + 3.0) tmp = 0.0 if (alpha <= -2e-15) tmp = Float64(Float64(1.0 + alpha) / Float64(t_1 * Float64(t_2 * t_1))); elseif (alpha <= 1.75) tmp = Float64(Float64(Float64(Float64(1.0 + beta) / Float64(2.0 + beta)) / t_0) / t_2); else tmp = Float64(Float64(Float64(alpha / Float64(t_0 / Float64(1.0 + beta))) / t_0) / t_2); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = alpha + (2.0 + beta); t_1 = 2.0 + (alpha + beta); t_2 = (alpha + beta) + 3.0; tmp = 0.0; if (alpha <= -2e-15) tmp = (1.0 + alpha) / (t_1 * (t_2 * t_1)); elseif (alpha <= 1.75) tmp = (((1.0 + beta) / (2.0 + beta)) / t_0) / t_2; else tmp = ((alpha / (t_0 / (1.0 + beta))) / t_0) / t_2; end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(2.0 + N[(alpha + beta), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]}, If[LessEqual[alpha, -2e-15], N[(N[(1.0 + alpha), $MachinePrecision] / N[(t$95$1 * N[(t$95$2 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[alpha, 1.75], N[(N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision], N[(N[(N[(alpha / N[(t$95$0 / N[(1.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(2 + \beta\right)\\
t_1 := 2 + \left(\alpha + \beta\right)\\
t_2 := \left(\alpha + \beta\right) + 3\\
\mathbf{if}\;\alpha \leq -2 \cdot 10^{-15}:\\
\;\;\;\;\frac{1 + \alpha}{t\_1 \cdot \left(t\_2 \cdot t\_1\right)}\\
\mathbf{elif}\;\alpha \leq 1.75:\\
\;\;\;\;\frac{\frac{\frac{1 + \beta}{2 + \beta}}{t\_0}}{t\_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{\alpha}{\frac{t\_0}{1 + \beta}}}{t\_0}}{t\_2}\\
\end{array}
\end{array}
if alpha < -2.0000000000000002e-15Initial program 99.1%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified99.2%
Taylor expanded in beta around 0
+-lowering-+.f6499.2%
Simplified99.2%
if -2.0000000000000002e-15 < alpha < 1.75Initial program 99.9%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9%
Applied egg-rr99.9%
/-lowering-/.f64N/A
Applied egg-rr99.9%
Taylor expanded in alpha around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6499.8%
Simplified99.8%
if 1.75 < alpha Initial program 81.7%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8%
Applied egg-rr99.8%
/-lowering-/.f64N/A
Applied egg-rr99.8%
Taylor expanded in alpha around inf
Simplified98.4%
Final simplification99.3%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) 3.0)) (t_1 (+ alpha (+ 2.0 beta))))
(if (<= beta 1.05e+16)
(* (/ (+ 1.0 beta) (* t_1 t_1)) (/ (+ 1.0 alpha) t_0))
(/ (/ (+ 1.0 alpha) t_1) t_0))))
double code(double alpha, double beta) {
double t_0 = (alpha + beta) + 3.0;
double t_1 = alpha + (2.0 + beta);
double tmp;
if (beta <= 1.05e+16) {
tmp = ((1.0 + beta) / (t_1 * t_1)) * ((1.0 + alpha) / t_0);
} else {
tmp = ((1.0 + alpha) / t_1) / 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 + (2.0d0 + beta)
if (beta <= 1.05d+16) then
tmp = ((1.0d0 + beta) / (t_1 * t_1)) * ((1.0d0 + alpha) / t_0)
else
tmp = ((1.0d0 + alpha) / t_1) / 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 + (2.0 + beta);
double tmp;
if (beta <= 1.05e+16) {
tmp = ((1.0 + beta) / (t_1 * t_1)) * ((1.0 + alpha) / t_0);
} else {
tmp = ((1.0 + alpha) / t_1) / t_0;
}
return tmp;
}
def code(alpha, beta): t_0 = (alpha + beta) + 3.0 t_1 = alpha + (2.0 + beta) tmp = 0 if beta <= 1.05e+16: tmp = ((1.0 + beta) / (t_1 * t_1)) * ((1.0 + alpha) / t_0) else: tmp = ((1.0 + alpha) / t_1) / t_0 return tmp
function code(alpha, beta) t_0 = Float64(Float64(alpha + beta) + 3.0) t_1 = Float64(alpha + Float64(2.0 + beta)) tmp = 0.0 if (beta <= 1.05e+16) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(t_1 * t_1)) * Float64(Float64(1.0 + alpha) / t_0)); else tmp = Float64(Float64(Float64(1.0 + alpha) / t_1) / t_0); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = (alpha + beta) + 3.0; t_1 = alpha + (2.0 + beta); tmp = 0.0; if (beta <= 1.05e+16) tmp = ((1.0 + beta) / (t_1 * t_1)) * ((1.0 + alpha) / t_0); else tmp = ((1.0 + alpha) / t_1) / t_0; end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]}, Block[{t$95$1 = N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 1.05e+16], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / t$95$1), $MachinePrecision] / t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 3\\
t_1 := \alpha + \left(2 + \beta\right)\\
\mathbf{if}\;\beta \leq 1.05 \cdot 10^{+16}:\\
\;\;\;\;\frac{1 + \beta}{t\_1 \cdot t\_1} \cdot \frac{1 + \alpha}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{t\_1}}{t\_0}\\
\end{array}
\end{array}
if beta < 1.05e16Initial program 99.8%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.8%
*-commutativeN/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
associate-*r*N/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr99.2%
if 1.05e16 < beta Initial program 75.6%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8%
Applied egg-rr99.8%
/-lowering-/.f64N/A
Applied egg-rr99.8%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f6499.6%
Applied egg-rr99.6%
Taylor expanded in beta around inf
+-commutativeN/A
+-lowering-+.f6481.9%
Simplified81.9%
Final simplification94.8%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 2.8e-8)
(/ (/ (+ 1.0 alpha) (* (+ alpha 2.0) (+ alpha 2.0))) (+ (+ alpha beta) 3.0))
(if (<= beta 3e+16)
(/
(/ (+ 1.0 beta) (+ 2.0 beta))
(+ (+ 6.0 (* beta 3.0)) (* beta (+ 2.0 beta))))
(/
(/ (+ 1.0 alpha) (+ 2.0 (+ alpha beta)))
(* beta (- (/ (- alpha -3.0) beta) -1.0))))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8e-8) {
tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / ((alpha + beta) + 3.0);
} else if (beta <= 3e+16) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta)));
} else {
tmp = ((1.0 + alpha) / (2.0 + (alpha + beta))) / (beta * (((alpha - -3.0) / beta) - -1.0));
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (beta <= 2.8d-8) then
tmp = ((1.0d0 + alpha) / ((alpha + 2.0d0) * (alpha + 2.0d0))) / ((alpha + beta) + 3.0d0)
else if (beta <= 3d+16) then
tmp = ((1.0d0 + beta) / (2.0d0 + beta)) / ((6.0d0 + (beta * 3.0d0)) + (beta * (2.0d0 + beta)))
else
tmp = ((1.0d0 + alpha) / (2.0d0 + (alpha + beta))) / (beta * (((alpha - (-3.0d0)) / beta) - (-1.0d0)))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8e-8) {
tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / ((alpha + beta) + 3.0);
} else if (beta <= 3e+16) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta)));
} else {
tmp = ((1.0 + alpha) / (2.0 + (alpha + beta))) / (beta * (((alpha - -3.0) / beta) - -1.0));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.8e-8: tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / ((alpha + beta) + 3.0) elif beta <= 3e+16: tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta))) else: tmp = ((1.0 + alpha) / (2.0 + (alpha + beta))) / (beta * (((alpha - -3.0) / beta) - -1.0)) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.8e-8) tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0))) / Float64(Float64(alpha + beta) + 3.0)); elseif (beta <= 3e+16) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(2.0 + beta)) / Float64(Float64(6.0 + Float64(beta * 3.0)) + Float64(beta * Float64(2.0 + beta)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(2.0 + Float64(alpha + beta))) / Float64(beta * Float64(Float64(Float64(alpha - -3.0) / beta) - -1.0))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.8e-8) tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / ((alpha + beta) + 3.0); elseif (beta <= 3e+16) tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta))); else tmp = ((1.0 + alpha) / (2.0 + (alpha + beta))) / (beta * (((alpha - -3.0) / beta) - -1.0)); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.8e-8], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3e+16], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision] / N[(N[(6.0 + N[(beta * 3.0), $MachinePrecision]), $MachinePrecision] + N[(beta * N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(2.0 + N[(alpha + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(beta * N[(N[(N[(alpha - -3.0), $MachinePrecision] / beta), $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8 \cdot 10^{-8}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)}}{\left(\alpha + \beta\right) + 3}\\
\mathbf{elif}\;\beta \leq 3 \cdot 10^{+16}:\\
\;\;\;\;\frac{\frac{1 + \beta}{2 + \beta}}{\left(6 + \beta \cdot 3\right) + \beta \cdot \left(2 + \beta\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{2 + \left(\alpha + \beta\right)}}{\beta \cdot \left(\frac{\alpha - -3}{\beta} - -1\right)}\\
\end{array}
\end{array}
if beta < 2.7999999999999999e-8Initial program 99.9%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9%
Applied egg-rr99.9%
/-lowering-/.f64N/A
Applied egg-rr99.9%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6498.7%
Simplified98.7%
if 2.7999999999999999e-8 < beta < 3e16Initial program 99.2%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified98.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.2%
Applied egg-rr99.2%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6480.5%
Simplified80.5%
if 3e16 < beta Initial program 75.6%
Taylor expanded in beta around inf
+-lowering-+.f6481.9%
Simplified81.9%
Taylor expanded in beta around -inf
associate-*r*N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
mul-1-negN/A
neg-lowering-neg.f6481.9%
Simplified81.9%
Final simplification93.7%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) 3.0)))
(if (<= beta 2.8e-8)
(/ (/ (+ 1.0 alpha) (* (+ alpha 2.0) (+ alpha 2.0))) t_0)
(if (<= beta 3e+16)
(/
(/ (+ 1.0 beta) (+ 2.0 beta))
(+ (+ 6.0 (* beta 3.0)) (* beta (+ 2.0 beta))))
(/ (/ (+ 1.0 alpha) t_0) (+ alpha (+ 2.0 beta)))))))
double code(double alpha, double beta) {
double t_0 = (alpha + beta) + 3.0;
double tmp;
if (beta <= 2.8e-8) {
tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0;
} else if (beta <= 3e+16) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta)));
} else {
tmp = ((1.0 + alpha) / t_0) / (alpha + (2.0 + beta));
}
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) + 3.0d0
if (beta <= 2.8d-8) then
tmp = ((1.0d0 + alpha) / ((alpha + 2.0d0) * (alpha + 2.0d0))) / t_0
else if (beta <= 3d+16) then
tmp = ((1.0d0 + beta) / (2.0d0 + beta)) / ((6.0d0 + (beta * 3.0d0)) + (beta * (2.0d0 + beta)))
else
tmp = ((1.0d0 + alpha) / t_0) / (alpha + (2.0d0 + beta))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = (alpha + beta) + 3.0;
double tmp;
if (beta <= 2.8e-8) {
tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0;
} else if (beta <= 3e+16) {
tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta)));
} else {
tmp = ((1.0 + alpha) / t_0) / (alpha + (2.0 + beta));
}
return tmp;
}
def code(alpha, beta): t_0 = (alpha + beta) + 3.0 tmp = 0 if beta <= 2.8e-8: tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0 elif beta <= 3e+16: tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta))) else: tmp = ((1.0 + alpha) / t_0) / (alpha + (2.0 + beta)) return tmp
function code(alpha, beta) t_0 = Float64(Float64(alpha + beta) + 3.0) tmp = 0.0 if (beta <= 2.8e-8) tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0))) / t_0); elseif (beta <= 3e+16) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(2.0 + beta)) / Float64(Float64(6.0 + Float64(beta * 3.0)) + Float64(beta * Float64(2.0 + beta)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / t_0) / Float64(alpha + Float64(2.0 + beta))); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = (alpha + beta) + 3.0; tmp = 0.0; if (beta <= 2.8e-8) tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0; elseif (beta <= 3e+16) tmp = ((1.0 + beta) / (2.0 + beta)) / ((6.0 + (beta * 3.0)) + (beta * (2.0 + beta))); else tmp = ((1.0 + alpha) / t_0) / (alpha + (2.0 + beta)); end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]}, If[LessEqual[beta, 2.8e-8], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[beta, 3e+16], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision] / N[(N[(6.0 + N[(beta * 3.0), $MachinePrecision]), $MachinePrecision] + N[(beta * N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 3\\
\mathbf{if}\;\beta \leq 2.8 \cdot 10^{-8}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)}}{t\_0}\\
\mathbf{elif}\;\beta \leq 3 \cdot 10^{+16}:\\
\;\;\;\;\frac{\frac{1 + \beta}{2 + \beta}}{\left(6 + \beta \cdot 3\right) + \beta \cdot \left(2 + \beta\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{t\_0}}{\alpha + \left(2 + \beta\right)}\\
\end{array}
\end{array}
if beta < 2.7999999999999999e-8Initial program 99.9%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9%
Applied egg-rr99.9%
/-lowering-/.f64N/A
Applied egg-rr99.9%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6498.7%
Simplified98.7%
if 2.7999999999999999e-8 < beta < 3e16Initial program 99.2%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified98.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.2%
Applied egg-rr99.2%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6480.5%
Simplified80.5%
if 3e16 < beta Initial program 75.6%
Taylor expanded in beta around inf
+-lowering-+.f6481.9%
Simplified81.9%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+r+N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6481.9%
Applied egg-rr81.9%
Final simplification93.7%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (+ (+ alpha beta) 3.0)))
(if (<= beta 2.8e-8)
(/ (/ (+ 1.0 alpha) (* (+ alpha 2.0) (+ alpha 2.0))) t_0)
(if (<= beta 5.5e+14)
(/ (/ (+ 1.0 beta) (+ 2.0 beta)) (+ 6.0 (* beta (+ beta 5.0))))
(/ (/ (+ 1.0 alpha) (+ alpha (+ 2.0 beta))) t_0)))))
double code(double alpha, double beta) {
double t_0 = (alpha + beta) + 3.0;
double tmp;
if (beta <= 2.8e-8) {
tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0;
} else if (beta <= 5.5e+14) {
tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0)));
} else {
tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / 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 = (alpha + beta) + 3.0d0
if (beta <= 2.8d-8) then
tmp = ((1.0d0 + alpha) / ((alpha + 2.0d0) * (alpha + 2.0d0))) / t_0
else if (beta <= 5.5d+14) then
tmp = ((1.0d0 + beta) / (2.0d0 + beta)) / (6.0d0 + (beta * (beta + 5.0d0)))
else
tmp = ((1.0d0 + alpha) / (alpha + (2.0d0 + beta))) / t_0
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = (alpha + beta) + 3.0;
double tmp;
if (beta <= 2.8e-8) {
tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0;
} else if (beta <= 5.5e+14) {
tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0)));
} else {
tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / t_0;
}
return tmp;
}
def code(alpha, beta): t_0 = (alpha + beta) + 3.0 tmp = 0 if beta <= 2.8e-8: tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0 elif beta <= 5.5e+14: tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0))) else: tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / t_0 return tmp
function code(alpha, beta) t_0 = Float64(Float64(alpha + beta) + 3.0) tmp = 0.0 if (beta <= 2.8e-8) tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0))) / t_0); elseif (beta <= 5.5e+14) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(2.0 + beta)) / Float64(6.0 + Float64(beta * Float64(beta + 5.0)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(alpha + Float64(2.0 + beta))) / t_0); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = (alpha + beta) + 3.0; tmp = 0.0; if (beta <= 2.8e-8) tmp = ((1.0 + alpha) / ((alpha + 2.0) * (alpha + 2.0))) / t_0; elseif (beta <= 5.5e+14) tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0))); else tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / t_0; end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]}, If[LessEqual[beta, 2.8e-8], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[beta, 5.5e+14], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision] / N[(6.0 + N[(beta * N[(beta + 5.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\alpha + \beta\right) + 3\\
\mathbf{if}\;\beta \leq 2.8 \cdot 10^{-8}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)}}{t\_0}\\
\mathbf{elif}\;\beta \leq 5.5 \cdot 10^{+14}:\\
\;\;\;\;\frac{\frac{1 + \beta}{2 + \beta}}{6 + \beta \cdot \left(\beta + 5\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\alpha + \left(2 + \beta\right)}}{t\_0}\\
\end{array}
\end{array}
if beta < 2.7999999999999999e-8Initial program 99.9%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.9%
Applied egg-rr99.9%
/-lowering-/.f64N/A
Applied egg-rr99.9%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6498.7%
Simplified98.7%
if 2.7999999999999999e-8 < beta < 5.5e14Initial program 99.2%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified98.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.2%
Applied egg-rr99.2%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6480.5%
Simplified80.5%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6480.5%
Simplified80.5%
if 5.5e14 < beta Initial program 75.6%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8%
Applied egg-rr99.8%
/-lowering-/.f64N/A
Applied egg-rr99.8%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f6499.6%
Applied egg-rr99.6%
Taylor expanded in beta around inf
+-commutativeN/A
+-lowering-+.f6481.9%
Simplified81.9%
Final simplification93.7%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1.95e-86)
(/ (/ (+ 1.0 alpha) (+ alpha 3.0)) (* (+ alpha 2.0) (+ alpha 2.0)))
(if (<= beta 3.4e+15)
(/ (/ (+ 1.0 beta) (+ 2.0 beta)) (+ 6.0 (* beta (+ beta 5.0))))
(/ (/ (+ 1.0 alpha) (+ alpha (+ 2.0 beta))) (+ (+ alpha beta) 3.0)))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.95e-86) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else if (beta <= 3.4e+15) {
tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0)));
} else {
tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / ((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 <= 1.95d-86) then
tmp = ((1.0d0 + alpha) / (alpha + 3.0d0)) / ((alpha + 2.0d0) * (alpha + 2.0d0))
else if (beta <= 3.4d+15) then
tmp = ((1.0d0 + beta) / (2.0d0 + beta)) / (6.0d0 + (beta * (beta + 5.0d0)))
else
tmp = ((1.0d0 + alpha) / (alpha + (2.0d0 + beta))) / ((alpha + beta) + 3.0d0)
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.95e-86) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else if (beta <= 3.4e+15) {
tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0)));
} else {
tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / ((alpha + beta) + 3.0);
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 1.95e-86: tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)) elif beta <= 3.4e+15: tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0))) else: tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / ((alpha + beta) + 3.0) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 1.95e-86) tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(alpha + 3.0)) / Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0))); elseif (beta <= 3.4e+15) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(2.0 + beta)) / Float64(6.0 + Float64(beta * Float64(beta + 5.0)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(alpha + Float64(2.0 + beta))) / Float64(Float64(alpha + beta) + 3.0)); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 1.95e-86) tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)); elseif (beta <= 3.4e+15) tmp = ((1.0 + beta) / (2.0 + beta)) / (6.0 + (beta * (beta + 5.0))); else tmp = ((1.0 + alpha) / (alpha + (2.0 + beta))) / ((alpha + beta) + 3.0); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 1.95e-86], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision] / N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.4e+15], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(2.0 + beta), $MachinePrecision]), $MachinePrecision] / N[(6.0 + N[(beta * N[(beta + 5.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.95 \cdot 10^{-86}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\alpha + 3}}{\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)}\\
\mathbf{elif}\;\beta \leq 3.4 \cdot 10^{+15}:\\
\;\;\;\;\frac{\frac{1 + \beta}{2 + \beta}}{6 + \beta \cdot \left(\beta + 5\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\alpha + \left(2 + \beta\right)}}{\left(\alpha + \beta\right) + 3}\\
\end{array}
\end{array}
if beta < 1.9500000000000001e-86Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.9%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.0%
Simplified96.0%
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.3%
Applied egg-rr98.3%
if 1.9500000000000001e-86 < beta < 3.4e15Initial program 99.6%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.2%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.5%
Applied egg-rr96.5%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6476.4%
Simplified76.4%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6476.4%
Simplified76.4%
if 3.4e15 < beta Initial program 75.6%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8%
Applied egg-rr99.8%
/-lowering-/.f64N/A
Applied egg-rr99.8%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f6499.6%
Applied egg-rr99.6%
Taylor expanded in beta around inf
+-commutativeN/A
+-lowering-+.f6481.9%
Simplified81.9%
Final simplification91.6%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1.5e-86)
(/ (/ (+ 1.0 alpha) (+ alpha 3.0)) (* (+ alpha 2.0) (+ alpha 2.0)))
(if (<= beta 3e+16)
(/ (/ (+ 1.0 beta) (* (+ 2.0 beta) (+ 2.0 beta))) (+ beta 3.0))
(/ (/ (+ 1.0 alpha) (+ (+ alpha beta) 3.0)) (+ alpha (+ 2.0 beta))))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.5e-86) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else if (beta <= 3e+16) {
tmp = ((1.0 + beta) / ((2.0 + beta) * (2.0 + beta))) / (beta + 3.0);
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (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 <= 1.5d-86) then
tmp = ((1.0d0 + alpha) / (alpha + 3.0d0)) / ((alpha + 2.0d0) * (alpha + 2.0d0))
else if (beta <= 3d+16) then
tmp = ((1.0d0 + beta) / ((2.0d0 + beta) * (2.0d0 + beta))) / (beta + 3.0d0)
else
tmp = ((1.0d0 + alpha) / ((alpha + beta) + 3.0d0)) / (alpha + (2.0d0 + beta))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.5e-86) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else if (beta <= 3e+16) {
tmp = ((1.0 + beta) / ((2.0 + beta) * (2.0 + beta))) / (beta + 3.0);
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (2.0 + beta));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 1.5e-86: tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)) elif beta <= 3e+16: tmp = ((1.0 + beta) / ((2.0 + beta) * (2.0 + beta))) / (beta + 3.0) else: tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (2.0 + beta)) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 1.5e-86) tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(alpha + 3.0)) / Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0))); elseif (beta <= 3e+16) tmp = Float64(Float64(Float64(1.0 + beta) / Float64(Float64(2.0 + beta) * Float64(2.0 + beta))) / Float64(beta + 3.0)); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + beta) + 3.0)) / Float64(alpha + Float64(2.0 + beta))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 1.5e-86) tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)); elseif (beta <= 3e+16) tmp = ((1.0 + beta) / ((2.0 + beta) * (2.0 + beta))) / (beta + 3.0); else tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (2.0 + beta)); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 1.5e-86], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision] / N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3e+16], N[(N[(N[(1.0 + beta), $MachinePrecision] / N[(N[(2.0 + beta), $MachinePrecision] * N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(beta + 3.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] / N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.5 \cdot 10^{-86}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\alpha + 3}}{\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)}\\
\mathbf{elif}\;\beta \leq 3 \cdot 10^{+16}:\\
\;\;\;\;\frac{\frac{1 + \beta}{\left(2 + \beta\right) \cdot \left(2 + \beta\right)}}{\beta + 3}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + \beta\right) + 3}}{\alpha + \left(2 + \beta\right)}\\
\end{array}
\end{array}
if beta < 1.5e-86Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.9%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.0%
Simplified96.0%
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6498.3%
Applied egg-rr98.3%
if 1.5e-86 < beta < 3e16Initial program 99.6%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.2%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6476.2%
Simplified76.2%
if 3e16 < beta Initial program 75.6%
Taylor expanded in beta around inf
+-lowering-+.f6481.9%
Simplified81.9%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+r+N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6481.9%
Applied egg-rr81.9%
Final simplification91.6%
(FPCore (alpha beta) :precision binary64 (let* ((t_0 (+ alpha (+ 2.0 beta)))) (* (/ (/ (+ 1.0 beta) t_0) (+ (+ alpha beta) 3.0)) (/ (+ 1.0 alpha) t_0))))
double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
return (((1.0 + beta) / t_0) / ((alpha + beta) + 3.0)) * ((1.0 + alpha) / t_0);
}
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 + beta) / t_0) / ((alpha + beta) + 3.0d0)) * ((1.0d0 + alpha) / t_0)
end function
public static double code(double alpha, double beta) {
double t_0 = alpha + (2.0 + beta);
return (((1.0 + beta) / t_0) / ((alpha + beta) + 3.0)) * ((1.0 + alpha) / t_0);
}
def code(alpha, beta): t_0 = alpha + (2.0 + beta) return (((1.0 + beta) / t_0) / ((alpha + beta) + 3.0)) * ((1.0 + alpha) / t_0)
function code(alpha, beta) t_0 = Float64(alpha + Float64(2.0 + beta)) return Float64(Float64(Float64(Float64(1.0 + beta) / t_0) / Float64(Float64(alpha + beta) + 3.0)) * Float64(Float64(1.0 + alpha) / t_0)) end
function tmp = code(alpha, beta) t_0 = alpha + (2.0 + beta); tmp = (((1.0 + beta) / t_0) / ((alpha + beta) + 3.0)) * ((1.0 + alpha) / t_0); end
code[alpha_, beta_] := Block[{t$95$0 = N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(1.0 + beta), $MachinePrecision] / t$95$0), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + alpha), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \alpha + \left(2 + \beta\right)\\
\frac{\frac{1 + \beta}{t\_0}}{\left(\alpha + \beta\right) + 3} \cdot \frac{1 + \alpha}{t\_0}
\end{array}
\end{array}
Initial program 93.7%
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
*-rgt-identityN/A
distribute-lft-inN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6499.8%
Applied egg-rr99.8%
associate-/l/N/A
+-commutativeN/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr99.8%
(FPCore (alpha beta) :precision binary64 (if (<= beta 1.3) (/ (/ (+ 1.0 alpha) (+ alpha 3.0)) (* (+ alpha 2.0) (+ alpha 2.0))) (/ (/ (+ 1.0 alpha) (+ (+ alpha beta) 3.0)) (+ alpha (+ 2.0 beta)))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.3) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (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 <= 1.3d0) then
tmp = ((1.0d0 + alpha) / (alpha + 3.0d0)) / ((alpha + 2.0d0) * (alpha + 2.0d0))
else
tmp = ((1.0d0 + alpha) / ((alpha + beta) + 3.0d0)) / (alpha + (2.0d0 + beta))
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.3) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (2.0 + beta));
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 1.3: tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)) else: tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (2.0 + beta)) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 1.3) tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(alpha + 3.0)) / Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + beta) + 3.0)) / Float64(alpha + Float64(2.0 + beta))); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 1.3) tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)); else tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / (alpha + (2.0 + beta)); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 1.3], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision] / N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] / N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.3:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\alpha + 3}}{\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + \beta\right) + 3}}{\alpha + \left(2 + \beta\right)}\\
\end{array}
\end{array}
if beta < 1.30000000000000004Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6494.2%
Simplified94.2%
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
if 1.30000000000000004 < beta Initial program 77.3%
Taylor expanded in beta around inf
+-lowering-+.f6478.5%
Simplified78.5%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+r+N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6478.5%
Applied egg-rr78.5%
(FPCore (alpha beta) :precision binary64 (if (<= beta 3.3) (/ (/ (+ 1.0 alpha) (+ alpha 3.0)) (* (+ alpha 2.0) (+ alpha 2.0))) (/ (/ (+ 1.0 alpha) (+ (+ alpha beta) 3.0)) beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 3.3) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.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 <= 3.3d0) then
tmp = ((1.0d0 + alpha) / (alpha + 3.0d0)) / ((alpha + 2.0d0) * (alpha + 2.0d0))
else
tmp = ((1.0d0 + alpha) / ((alpha + beta) + 3.0d0)) / beta
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 3.3) {
tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 3.3: tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)) else: tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 3.3) tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(alpha + 3.0)) / Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + beta) + 3.0)) / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 3.3) tmp = ((1.0 + alpha) / (alpha + 3.0)) / ((alpha + 2.0) * (alpha + 2.0)); else tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 3.3], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision] / N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 3.3:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\alpha + 3}}{\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + \beta\right) + 3}}{\beta}\\
\end{array}
\end{array}
if beta < 3.2999999999999998Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6494.2%
Simplified94.2%
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
if 3.2999999999999998 < beta Initial program 77.3%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f6477.7%
Simplified77.7%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f6477.7%
Applied egg-rr77.7%
(FPCore (alpha beta) :precision binary64 (if (<= beta 3.3) (/ (+ 1.0 alpha) (* (* (+ alpha 2.0) (+ alpha 2.0)) (+ alpha 3.0))) (/ (/ (+ 1.0 alpha) (+ (+ alpha beta) 3.0)) beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 3.3) {
tmp = (1.0 + alpha) / (((alpha + 2.0) * (alpha + 2.0)) * (alpha + 3.0));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.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 <= 3.3d0) then
tmp = (1.0d0 + alpha) / (((alpha + 2.0d0) * (alpha + 2.0d0)) * (alpha + 3.0d0))
else
tmp = ((1.0d0 + alpha) / ((alpha + beta) + 3.0d0)) / beta
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 3.3) {
tmp = (1.0 + alpha) / (((alpha + 2.0) * (alpha + 2.0)) * (alpha + 3.0));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 3.3: tmp = (1.0 + alpha) / (((alpha + 2.0) * (alpha + 2.0)) * (alpha + 3.0)) else: tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 3.3) tmp = Float64(Float64(1.0 + alpha) / Float64(Float64(Float64(alpha + 2.0) * Float64(alpha + 2.0)) * Float64(alpha + 3.0))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + beta) + 3.0)) / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 3.3) tmp = (1.0 + alpha) / (((alpha + 2.0) * (alpha + 2.0)) * (alpha + 3.0)); else tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 3.3], N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(N[(alpha + 2.0), $MachinePrecision] * N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision] * N[(alpha + 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 3.3:\\
\;\;\;\;\frac{1 + \alpha}{\left(\left(\alpha + 2\right) \cdot \left(\alpha + 2\right)\right) \cdot \left(\alpha + 3\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + \beta\right) + 3}}{\beta}\\
\end{array}
\end{array}
if beta < 3.2999999999999998Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6494.2%
Simplified94.2%
if 3.2999999999999998 < beta Initial program 77.3%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f6477.7%
Simplified77.7%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f6477.7%
Applied egg-rr77.7%
Final simplification89.7%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1.7)
(+
0.08333333333333333
(*
beta
(+
(* beta (+ (* beta 0.024691358024691357) -0.011574074074074073))
-0.027777777777777776)))
(/ (/ (+ 1.0 alpha) (+ (+ alpha beta) 3.0)) beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.7) {
tmp = 0.08333333333333333 + (beta * ((beta * ((beta * 0.024691358024691357) + -0.011574074074074073)) + -0.027777777777777776));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.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 <= 1.7d0) then
tmp = 0.08333333333333333d0 + (beta * ((beta * ((beta * 0.024691358024691357d0) + (-0.011574074074074073d0))) + (-0.027777777777777776d0)))
else
tmp = ((1.0d0 + alpha) / ((alpha + beta) + 3.0d0)) / beta
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.7) {
tmp = 0.08333333333333333 + (beta * ((beta * ((beta * 0.024691358024691357) + -0.011574074074074073)) + -0.027777777777777776));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 1.7: tmp = 0.08333333333333333 + (beta * ((beta * ((beta * 0.024691358024691357) + -0.011574074074074073)) + -0.027777777777777776)) else: tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 1.7) tmp = Float64(0.08333333333333333 + Float64(beta * Float64(Float64(beta * Float64(Float64(beta * 0.024691358024691357) + -0.011574074074074073)) + -0.027777777777777776))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + beta) + 3.0)) / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 1.7) tmp = 0.08333333333333333 + (beta * ((beta * ((beta * 0.024691358024691357) + -0.011574074074074073)) + -0.027777777777777776)); else tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 1.7], N[(0.08333333333333333 + N[(beta * N[(N[(beta * N[(N[(beta * 0.024691358024691357), $MachinePrecision] + -0.011574074074074073), $MachinePrecision]), $MachinePrecision] + -0.027777777777777776), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.7:\\
\;\;\;\;0.08333333333333333 + \beta \cdot \left(\beta \cdot \left(\beta \cdot 0.024691358024691357 + -0.011574074074074073\right) + -0.027777777777777776\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + \beta\right) + 3}}{\beta}\\
\end{array}
\end{array}
if beta < 1.69999999999999996Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6469.4%
Simplified69.4%
if 1.69999999999999996 < beta Initial program 77.3%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f6477.7%
Simplified77.7%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f6477.7%
Applied egg-rr77.7%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 2.1)
(+
0.08333333333333333
(*
alpha
(+
-0.027777777777777776
(* alpha (+ -0.011574074074074073 (* alpha 0.024691358024691357))))))
(/ (/ (+ 1.0 alpha) (+ (+ alpha beta) 3.0)) beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.1) {
tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * (-0.011574074074074073 + (alpha * 0.024691358024691357)))));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.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 <= 2.1d0) then
tmp = 0.08333333333333333d0 + (alpha * ((-0.027777777777777776d0) + (alpha * ((-0.011574074074074073d0) + (alpha * 0.024691358024691357d0)))))
else
tmp = ((1.0d0 + alpha) / ((alpha + beta) + 3.0d0)) / beta
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.1) {
tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * (-0.011574074074074073 + (alpha * 0.024691358024691357)))));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.1: tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * (-0.011574074074074073 + (alpha * 0.024691358024691357))))) else: tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.1) tmp = Float64(0.08333333333333333 + Float64(alpha * Float64(-0.027777777777777776 + Float64(alpha * Float64(-0.011574074074074073 + Float64(alpha * 0.024691358024691357)))))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + beta) + 3.0)) / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.1) tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * (-0.011574074074074073 + (alpha * 0.024691358024691357))))); else tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.1], N[(0.08333333333333333 + N[(alpha * N[(-0.027777777777777776 + N[(alpha * N[(-0.011574074074074073 + N[(alpha * 0.024691358024691357), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.1:\\
\;\;\;\;0.08333333333333333 + \alpha \cdot \left(-0.027777777777777776 + \alpha \cdot \left(-0.011574074074074073 + \alpha \cdot 0.024691358024691357\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + \beta\right) + 3}}{\beta}\\
\end{array}
\end{array}
if beta < 2.10000000000000009Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6494.2%
Simplified94.2%
Taylor expanded in alpha around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6467.5%
Simplified67.5%
if 2.10000000000000009 < beta Initial program 77.3%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f6477.7%
Simplified77.7%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f6477.7%
Applied egg-rr77.7%
Final simplification70.3%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 2.8)
(+ 0.08333333333333333 (* beta -0.027777777777777776))
(if (<= beta 1.35e+154)
(/ (+ 1.0 alpha) (* beta beta))
(/ (/ alpha beta) beta))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else if (beta <= 1.35e+154) {
tmp = (1.0 + alpha) / (beta * beta);
} else {
tmp = (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 if (beta <= 1.35d+154) then
tmp = (1.0d0 + alpha) / (beta * beta)
else
tmp = (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 if (beta <= 1.35e+154) {
tmp = (1.0 + alpha) / (beta * beta);
} else {
tmp = (alpha / beta) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.8: tmp = 0.08333333333333333 + (beta * -0.027777777777777776) elif beta <= 1.35e+154: tmp = (1.0 + alpha) / (beta * beta) else: tmp = (alpha / beta) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.8) tmp = Float64(0.08333333333333333 + Float64(beta * -0.027777777777777776)); elseif (beta <= 1.35e+154) tmp = Float64(Float64(1.0 + alpha) / Float64(beta * beta)); else tmp = Float64(Float64(alpha / 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); elseif (beta <= 1.35e+154) tmp = (1.0 + alpha) / (beta * beta); else tmp = (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], If[LessEqual[beta, 1.35e+154], N[(N[(1.0 + alpha), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision], N[(N[(alpha / beta), $MachinePrecision] / beta), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{elif}\;\beta \leq 1.35 \cdot 10^{+154}:\\
\;\;\;\;\frac{1 + \alpha}{\beta \cdot \beta}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\alpha}{\beta}}{\beta}\\
\end{array}
\end{array}
if beta < 2.7999999999999998Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6468.6%
Simplified68.6%
if 2.7999999999999998 < beta < 1.35000000000000003e154Initial program 91.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified57.6%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6467.5%
Simplified67.5%
if 1.35000000000000003e154 < beta Initial program 60.0%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified50.6%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6478.6%
Simplified78.6%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6488.9%
Applied egg-rr88.9%
Taylor expanded in alpha around inf
Simplified88.9%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1.5)
(+
0.08333333333333333
(* beta (+ -0.027777777777777776 (* beta -0.011574074074074073))))
(/ (/ (+ 1.0 alpha) (+ (+ alpha beta) 3.0)) beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.5) {
tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073)));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.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 <= 1.5d0) then
tmp = 0.08333333333333333d0 + (beta * ((-0.027777777777777776d0) + (beta * (-0.011574074074074073d0))))
else
tmp = ((1.0d0 + alpha) / ((alpha + beta) + 3.0d0)) / beta
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 1.5) {
tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073)));
} else {
tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 1.5: tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073))) else: tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 1.5) tmp = Float64(0.08333333333333333 + Float64(beta * Float64(-0.027777777777777776 + Float64(beta * -0.011574074074074073)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / Float64(Float64(alpha + beta) + 3.0)) / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 1.5) tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073))); else tmp = ((1.0 + alpha) / ((alpha + beta) + 3.0)) / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 1.5], N[(0.08333333333333333 + N[(beta * N[(-0.027777777777777776 + N[(beta * -0.011574074074074073), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 3.0), $MachinePrecision]), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.5:\\
\;\;\;\;0.08333333333333333 + \beta \cdot \left(-0.027777777777777776 + \beta \cdot -0.011574074074074073\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\left(\alpha + \beta\right) + 3}}{\beta}\\
\end{array}
\end{array}
if beta < 1.5Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6469.0%
Simplified69.0%
if 1.5 < beta Initial program 77.3%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f6477.7%
Simplified77.7%
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
associate-+l+N/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f6477.7%
Applied egg-rr77.7%
Final simplification71.4%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.8) (+ 0.08333333333333333 (* beta -0.027777777777777776)) (if (<= beta 2.2e+154) (/ (/ 1.0 beta) beta) (/ (/ alpha beta) beta))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else if (beta <= 2.2e+154) {
tmp = (1.0 / beta) / beta;
} else {
tmp = (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 if (beta <= 2.2d+154) then
tmp = (1.0d0 / beta) / beta
else
tmp = (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 if (beta <= 2.2e+154) {
tmp = (1.0 / beta) / beta;
} else {
tmp = (alpha / beta) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.8: tmp = 0.08333333333333333 + (beta * -0.027777777777777776) elif beta <= 2.2e+154: tmp = (1.0 / beta) / beta else: tmp = (alpha / beta) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.8) tmp = Float64(0.08333333333333333 + Float64(beta * -0.027777777777777776)); elseif (beta <= 2.2e+154) tmp = Float64(Float64(1.0 / beta) / beta); else tmp = Float64(Float64(alpha / 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); elseif (beta <= 2.2e+154) tmp = (1.0 / beta) / beta; else tmp = (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], If[LessEqual[beta, 2.2e+154], N[(N[(1.0 / beta), $MachinePrecision] / beta), $MachinePrecision], N[(N[(alpha / beta), $MachinePrecision] / beta), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{elif}\;\beta \leq 2.2 \cdot 10^{+154}:\\
\;\;\;\;\frac{\frac{1}{\beta}}{\beta}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\alpha}{\beta}}{\beta}\\
\end{array}
\end{array}
if beta < 2.7999999999999998Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6468.6%
Simplified68.6%
if 2.7999999999999998 < beta < 2.2000000000000001e154Initial program 91.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified57.6%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6467.5%
Simplified67.5%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6467.8%
Applied egg-rr67.8%
Taylor expanded in alpha around 0
Simplified63.2%
if 2.2000000000000001e154 < beta Initial program 60.0%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified50.6%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6478.6%
Simplified78.6%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6488.9%
Applied egg-rr88.9%
Taylor expanded in alpha around inf
Simplified88.9%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 1.7)
(+
0.08333333333333333
(* beta (+ -0.027777777777777776 (* beta -0.011574074074074073))))
(/ (/ (+ 1.0 alpha) beta) beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 1.7) {
tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073)));
} 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 <= 1.7d0) then
tmp = 0.08333333333333333d0 + (beta * ((-0.027777777777777776d0) + (beta * (-0.011574074074074073d0))))
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 <= 1.7) {
tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073)));
} else {
tmp = ((1.0 + alpha) / beta) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 1.7: tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073))) else: tmp = ((1.0 + alpha) / beta) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 1.7) tmp = Float64(0.08333333333333333 + Float64(beta * Float64(-0.027777777777777776 + Float64(beta * -0.011574074074074073)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / beta) / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 1.7) tmp = 0.08333333333333333 + (beta * (-0.027777777777777776 + (beta * -0.011574074074074073))); else tmp = ((1.0 + alpha) / beta) / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 1.7], N[(0.08333333333333333 + N[(beta * N[(-0.027777777777777776 + N[(beta * -0.011574074074074073), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / beta), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.7:\\
\;\;\;\;0.08333333333333333 + \beta \cdot \left(-0.027777777777777776 + \beta \cdot -0.011574074074074073\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\beta}}{\beta}\\
\end{array}
\end{array}
if beta < 1.69999999999999996Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6469.0%
Simplified69.0%
if 1.69999999999999996 < beta Initial program 77.3%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified54.4%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6472.6%
Simplified72.6%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6477.4%
Applied egg-rr77.4%
Final simplification71.3%
(FPCore (alpha beta)
:precision binary64
(if (<= beta 3.2)
(+
0.08333333333333333
(* alpha (+ -0.027777777777777776 (* alpha -0.011574074074074073))))
(/ (/ (+ 1.0 alpha) beta) beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 3.2) {
tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * -0.011574074074074073)));
} 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 <= 3.2d0) then
tmp = 0.08333333333333333d0 + (alpha * ((-0.027777777777777776d0) + (alpha * (-0.011574074074074073d0))))
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 <= 3.2) {
tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * -0.011574074074074073)));
} else {
tmp = ((1.0 + alpha) / beta) / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 3.2: tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * -0.011574074074074073))) else: tmp = ((1.0 + alpha) / beta) / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 3.2) tmp = Float64(0.08333333333333333 + Float64(alpha * Float64(-0.027777777777777776 + Float64(alpha * -0.011574074074074073)))); else tmp = Float64(Float64(Float64(1.0 + alpha) / beta) / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 3.2) tmp = 0.08333333333333333 + (alpha * (-0.027777777777777776 + (alpha * -0.011574074074074073))); else tmp = ((1.0 + alpha) / beta) / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 3.2], N[(0.08333333333333333 + N[(alpha * N[(-0.027777777777777776 + N[(alpha * -0.011574074074074073), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + alpha), $MachinePrecision] / beta), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 3.2:\\
\;\;\;\;0.08333333333333333 + \alpha \cdot \left(-0.027777777777777776 + \alpha \cdot -0.011574074074074073\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\beta}}{\beta}\\
\end{array}
\end{array}
if beta < 3.2000000000000002Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6494.2%
Simplified94.2%
Taylor expanded in alpha around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6467.1%
Simplified67.1%
if 3.2000000000000002 < beta Initial program 77.3%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified54.4%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6472.6%
Simplified72.6%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6477.4%
Applied egg-rr77.4%
Final simplification70.0%
(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(Float64(1.0 + alpha) / 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[(N[(1.0 + alpha), $MachinePrecision] / beta), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \alpha}{\beta}}{\beta}\\
\end{array}
\end{array}
if beta < 2.7999999999999998Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6468.6%
Simplified68.6%
if 2.7999999999999998 < beta Initial program 77.3%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified54.4%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6472.6%
Simplified72.6%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6477.4%
Applied egg-rr77.4%
(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(Float64(1.0 / 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[(N[(1.0 / beta), $MachinePrecision] / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{\beta}}{\beta}\\
\end{array}
\end{array}
if beta < 2.7999999999999998Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6468.6%
Simplified68.6%
if 2.7999999999999998 < beta Initial program 77.3%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified54.4%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6472.6%
Simplified72.6%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6477.4%
Applied egg-rr77.4%
Taylor expanded in alpha around 0
Simplified70.2%
(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/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6468.6%
Simplified68.6%
if 2.7999999999999998 < beta Initial program 77.3%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified54.4%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6472.6%
Simplified72.6%
Taylor expanded in alpha around 0
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6470.1%
Simplified70.1%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.8) (+ 0.08333333333333333 (* beta -0.027777777777777776)) (/ 0.3333333333333333 beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.8) {
tmp = 0.08333333333333333 + (beta * -0.027777777777777776);
} else {
tmp = 0.3333333333333333 / 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 = 0.3333333333333333d0 / 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 = 0.3333333333333333 / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.8: tmp = 0.08333333333333333 + (beta * -0.027777777777777776) else: tmp = 0.3333333333333333 / 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(0.3333333333333333 / 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 = 0.3333333333333333 / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.8], N[(0.08333333333333333 + N[(beta * -0.027777777777777776), $MachinePrecision]), $MachinePrecision], N[(0.3333333333333333 / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.8:\\
\;\;\;\;0.08333333333333333 + \beta \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\frac{0.3333333333333333}{\beta}\\
\end{array}
\end{array}
if beta < 2.7999999999999998Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
+-commutativeN/A
distribute-rgt-inN/A
+-lowering-+.f64N/A
distribute-lft-inN/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-+l+N/A
+-lowering-+.f64N/A
+-lowering-+.f6496.7%
Applied egg-rr96.7%
Taylor expanded in alpha around 0
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6469.7%
Simplified69.7%
Taylor expanded in beta around 0
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6468.6%
Simplified68.6%
if 2.7999999999999998 < beta Initial program 77.3%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f6477.7%
Simplified77.7%
flip-+N/A
div-invN/A
*-lowering-*.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6471.2%
Applied egg-rr71.2%
Taylor expanded in alpha around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6470.2%
Simplified70.2%
Taylor expanded in beta around 0
/-lowering-/.f646.9%
Simplified6.9%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.9) (+ 0.08333333333333333 (* alpha -0.027777777777777776)) (/ 0.3333333333333333 beta)))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.9) {
tmp = 0.08333333333333333 + (alpha * -0.027777777777777776);
} else {
tmp = 0.3333333333333333 / 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.9d0) then
tmp = 0.08333333333333333d0 + (alpha * (-0.027777777777777776d0))
else
tmp = 0.3333333333333333d0 / beta
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.9) {
tmp = 0.08333333333333333 + (alpha * -0.027777777777777776);
} else {
tmp = 0.3333333333333333 / beta;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.9: tmp = 0.08333333333333333 + (alpha * -0.027777777777777776) else: tmp = 0.3333333333333333 / beta return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.9) tmp = Float64(0.08333333333333333 + Float64(alpha * -0.027777777777777776)); else tmp = Float64(0.3333333333333333 / beta); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.9) tmp = 0.08333333333333333 + (alpha * -0.027777777777777776); else tmp = 0.3333333333333333 / beta; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.9], N[(0.08333333333333333 + N[(alpha * -0.027777777777777776), $MachinePrecision]), $MachinePrecision], N[(0.3333333333333333 / beta), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.9:\\
\;\;\;\;0.08333333333333333 + \alpha \cdot -0.027777777777777776\\
\mathbf{else}:\\
\;\;\;\;\frac{0.3333333333333333}{\beta}\\
\end{array}
\end{array}
if beta < 2.89999999999999991Initial program 99.9%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified96.7%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6494.2%
Simplified94.2%
Taylor expanded in alpha around 0
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6467.1%
Simplified67.1%
if 2.89999999999999991 < beta Initial program 77.3%
Taylor expanded in beta around inf
/-lowering-/.f64N/A
+-lowering-+.f6477.7%
Simplified77.7%
flip-+N/A
div-invN/A
*-lowering-*.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6471.2%
Applied egg-rr71.2%
Taylor expanded in alpha around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f6470.2%
Simplified70.2%
Taylor expanded in beta around 0
/-lowering-/.f646.9%
Simplified6.9%
(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 93.7%
associate-/l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
+-commutativeN/A
associate-+l+N/A
associate-+l+N/A
associate-+r+N/A
distribute-lft1-inN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
Simplified85.2%
Taylor expanded in beta around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f6474.5%
Simplified74.5%
Taylor expanded in alpha around 0
Simplified50.2%
herbie shell --seed 2024161
(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)))