
(FPCore (alpha beta) :precision binary64 (/ (+ (/ (- beta alpha) (+ (+ alpha beta) 2.0)) 1.0) 2.0))
double code(double alpha, double beta) {
return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = (((beta - alpha) / ((alpha + beta) + 2.0d0)) + 1.0d0) / 2.0d0
end function
public static double code(double alpha, double beta) {
return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0;
}
def code(alpha, beta): return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0
function code(alpha, beta) return Float64(Float64(Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + 2.0)) + 1.0) / 2.0) end
function tmp = code(alpha, beta) tmp = (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0; end
code[alpha_, beta_] := N[(N[(N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} + 1}{2}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (alpha beta) :precision binary64 (/ (+ (/ (- beta alpha) (+ (+ alpha beta) 2.0)) 1.0) 2.0))
double code(double alpha, double beta) {
return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = (((beta - alpha) / ((alpha + beta) + 2.0d0)) + 1.0d0) / 2.0d0
end function
public static double code(double alpha, double beta) {
return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0;
}
def code(alpha, beta): return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0
function code(alpha, beta) return Float64(Float64(Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + 2.0)) + 1.0) / 2.0) end
function tmp = code(alpha, beta) tmp = (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0; end
code[alpha_, beta_] := N[(N[(N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} + 1}{2}
\end{array}
(FPCore (alpha beta)
:precision binary64
(if (<= (/ (- beta alpha) (+ (+ beta alpha) 2.0)) -0.95)
(/ (+ 1.0 (- (* beta (- 1.0 (/ beta alpha))) (/ 2.0 alpha))) alpha)
(pow
(pow (fma (- alpha beta) (/ -0.5 (+ alpha (+ beta 2.0))) 0.5) 3.0)
0.3333333333333333)))
double code(double alpha, double beta) {
double tmp;
if (((beta - alpha) / ((beta + alpha) + 2.0)) <= -0.95) {
tmp = (1.0 + ((beta * (1.0 - (beta / alpha))) - (2.0 / alpha))) / alpha;
} else {
tmp = pow(pow(fma((alpha - beta), (-0.5 / (alpha + (beta + 2.0))), 0.5), 3.0), 0.3333333333333333);
}
return tmp;
}
function code(alpha, beta) tmp = 0.0 if (Float64(Float64(beta - alpha) / Float64(Float64(beta + alpha) + 2.0)) <= -0.95) tmp = Float64(Float64(1.0 + Float64(Float64(beta * Float64(1.0 - Float64(beta / alpha))) - Float64(2.0 / alpha))) / alpha); else tmp = (fma(Float64(alpha - beta), Float64(-0.5 / Float64(alpha + Float64(beta + 2.0))), 0.5) ^ 3.0) ^ 0.3333333333333333; end return tmp end
code[alpha_, beta_] := If[LessEqual[N[(N[(beta - alpha), $MachinePrecision] / N[(N[(beta + alpha), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision], -0.95], N[(N[(1.0 + N[(N[(beta * N[(1.0 - N[(beta / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(2.0 / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision], N[Power[N[Power[N[(N[(alpha - beta), $MachinePrecision] * N[(-0.5 / N[(alpha + N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 0.5), $MachinePrecision], 3.0], $MachinePrecision], 0.3333333333333333], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\beta - \alpha}{\left(\beta + \alpha\right) + 2} \leq -0.95:\\
\;\;\;\;\frac{1 + \left(\beta \cdot \left(1 - \frac{\beta}{\alpha}\right) - \frac{2}{\alpha}\right)}{\alpha}\\
\mathbf{else}:\\
\;\;\;\;{\left({\left(\mathsf{fma}\left(\alpha - \beta, \frac{-0.5}{\alpha + \left(\beta + 2\right)}, 0.5\right)\right)}^{3}\right)}^{0.3333333333333333}\\
\end{array}
\end{array}
if (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) < -0.94999999999999996Initial program 8.0%
+-commutative8.0%
sub-neg8.0%
+-commutative8.0%
neg-sub08.0%
associate-+l-8.0%
sub0-neg8.0%
distribute-frac-neg8.0%
+-commutative8.0%
sub-neg8.0%
div-sub8.0%
sub-neg8.0%
metadata-eval8.0%
neg-mul-18.0%
*-commutative8.0%
+-commutative8.0%
associate-/l/8.0%
associate-*l/8.0%
Simplified7.6%
Taylor expanded in alpha around inf 96.9%
Taylor expanded in beta around 0 99.8%
associate--l+99.8%
associate--l+99.8%
associate-*r/99.8%
mul-1-neg99.8%
associate-*r/99.8%
metadata-eval99.8%
associate-*r/99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in beta around inf 99.8%
mul-1-neg99.8%
Simplified99.8%
if -0.94999999999999996 < (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) Initial program 100.0%
+-commutative100.0%
sub-neg100.0%
+-commutative100.0%
neg-sub0100.0%
associate-+l-100.0%
sub0-neg100.0%
distribute-frac-neg100.0%
+-commutative100.0%
sub-neg100.0%
div-sub100.0%
sub-neg100.0%
metadata-eval100.0%
neg-mul-1100.0%
*-commutative100.0%
+-commutative100.0%
associate-/l/100.0%
associate-*l/100.0%
Simplified100.0%
add-cbrt-cube99.1%
pow1/3100.0%
pow3100.0%
+-commutative100.0%
fma-define100.0%
associate-+r+100.0%
+-commutative100.0%
associate-+l+100.0%
Applied egg-rr100.0%
Final simplification99.9%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (/ (- beta alpha) (+ (+ beta alpha) 2.0))))
(if (<= t_0 -0.95)
(/ (+ 1.0 (- (* beta (- 1.0 (/ beta alpha))) (/ 2.0 alpha))) alpha)
(/ (+ t_0 1.0) 2.0))))
double code(double alpha, double beta) {
double t_0 = (beta - alpha) / ((beta + alpha) + 2.0);
double tmp;
if (t_0 <= -0.95) {
tmp = (1.0 + ((beta * (1.0 - (beta / alpha))) - (2.0 / alpha))) / alpha;
} else {
tmp = (t_0 + 1.0) / 2.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 = (beta - alpha) / ((beta + alpha) + 2.0d0)
if (t_0 <= (-0.95d0)) then
tmp = (1.0d0 + ((beta * (1.0d0 - (beta / alpha))) - (2.0d0 / alpha))) / alpha
else
tmp = (t_0 + 1.0d0) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = (beta - alpha) / ((beta + alpha) + 2.0);
double tmp;
if (t_0 <= -0.95) {
tmp = (1.0 + ((beta * (1.0 - (beta / alpha))) - (2.0 / alpha))) / alpha;
} else {
tmp = (t_0 + 1.0) / 2.0;
}
return tmp;
}
def code(alpha, beta): t_0 = (beta - alpha) / ((beta + alpha) + 2.0) tmp = 0 if t_0 <= -0.95: tmp = (1.0 + ((beta * (1.0 - (beta / alpha))) - (2.0 / alpha))) / alpha else: tmp = (t_0 + 1.0) / 2.0 return tmp
function code(alpha, beta) t_0 = Float64(Float64(beta - alpha) / Float64(Float64(beta + alpha) + 2.0)) tmp = 0.0 if (t_0 <= -0.95) tmp = Float64(Float64(1.0 + Float64(Float64(beta * Float64(1.0 - Float64(beta / alpha))) - Float64(2.0 / alpha))) / alpha); else tmp = Float64(Float64(t_0 + 1.0) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = (beta - alpha) / ((beta + alpha) + 2.0); tmp = 0.0; if (t_0 <= -0.95) tmp = (1.0 + ((beta * (1.0 - (beta / alpha))) - (2.0 / alpha))) / alpha; else tmp = (t_0 + 1.0) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(beta - alpha), $MachinePrecision] / N[(N[(beta + alpha), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -0.95], N[(N[(1.0 + N[(N[(beta * N[(1.0 - N[(beta / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(2.0 / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / alpha), $MachinePrecision], N[(N[(t$95$0 + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\beta - \alpha}{\left(\beta + \alpha\right) + 2}\\
\mathbf{if}\;t\_0 \leq -0.95:\\
\;\;\;\;\frac{1 + \left(\beta \cdot \left(1 - \frac{\beta}{\alpha}\right) - \frac{2}{\alpha}\right)}{\alpha}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0 + 1}{2}\\
\end{array}
\end{array}
if (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) < -0.94999999999999996Initial program 8.0%
+-commutative8.0%
sub-neg8.0%
+-commutative8.0%
neg-sub08.0%
associate-+l-8.0%
sub0-neg8.0%
distribute-frac-neg8.0%
+-commutative8.0%
sub-neg8.0%
div-sub8.0%
sub-neg8.0%
metadata-eval8.0%
neg-mul-18.0%
*-commutative8.0%
+-commutative8.0%
associate-/l/8.0%
associate-*l/8.0%
Simplified7.6%
Taylor expanded in alpha around inf 96.9%
Taylor expanded in beta around 0 99.8%
associate--l+99.8%
associate--l+99.8%
associate-*r/99.8%
mul-1-neg99.8%
associate-*r/99.8%
metadata-eval99.8%
associate-*r/99.8%
metadata-eval99.8%
Simplified99.8%
Taylor expanded in beta around inf 99.8%
mul-1-neg99.8%
Simplified99.8%
if -0.94999999999999996 < (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) Initial program 100.0%
Final simplification99.9%
(FPCore (alpha beta) :precision binary64 (let* ((t_0 (/ (- beta alpha) (+ (+ beta alpha) 2.0)))) (if (<= t_0 -0.99999995) (/ (+ beta 1.0) alpha) (/ (+ t_0 1.0) 2.0))))
double code(double alpha, double beta) {
double t_0 = (beta - alpha) / ((beta + alpha) + 2.0);
double tmp;
if (t_0 <= -0.99999995) {
tmp = (beta + 1.0) / alpha;
} else {
tmp = (t_0 + 1.0) / 2.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 = (beta - alpha) / ((beta + alpha) + 2.0d0)
if (t_0 <= (-0.99999995d0)) then
tmp = (beta + 1.0d0) / alpha
else
tmp = (t_0 + 1.0d0) / 2.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = (beta - alpha) / ((beta + alpha) + 2.0);
double tmp;
if (t_0 <= -0.99999995) {
tmp = (beta + 1.0) / alpha;
} else {
tmp = (t_0 + 1.0) / 2.0;
}
return tmp;
}
def code(alpha, beta): t_0 = (beta - alpha) / ((beta + alpha) + 2.0) tmp = 0 if t_0 <= -0.99999995: tmp = (beta + 1.0) / alpha else: tmp = (t_0 + 1.0) / 2.0 return tmp
function code(alpha, beta) t_0 = Float64(Float64(beta - alpha) / Float64(Float64(beta + alpha) + 2.0)) tmp = 0.0 if (t_0 <= -0.99999995) tmp = Float64(Float64(beta + 1.0) / alpha); else tmp = Float64(Float64(t_0 + 1.0) / 2.0); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = (beta - alpha) / ((beta + alpha) + 2.0); tmp = 0.0; if (t_0 <= -0.99999995) tmp = (beta + 1.0) / alpha; else tmp = (t_0 + 1.0) / 2.0; end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(beta - alpha), $MachinePrecision] / N[(N[(beta + alpha), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -0.99999995], N[(N[(beta + 1.0), $MachinePrecision] / alpha), $MachinePrecision], N[(N[(t$95$0 + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\beta - \alpha}{\left(\beta + \alpha\right) + 2}\\
\mathbf{if}\;t\_0 \leq -0.99999995:\\
\;\;\;\;\frac{\beta + 1}{\alpha}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0 + 1}{2}\\
\end{array}
\end{array}
if (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) < -0.999999949999999971Initial program 7.0%
+-commutative7.0%
sub-neg7.0%
+-commutative7.0%
neg-sub07.0%
associate-+l-7.0%
sub0-neg7.0%
distribute-frac-neg7.0%
+-commutative7.0%
sub-neg7.0%
div-sub7.0%
sub-neg7.0%
metadata-eval7.0%
neg-mul-17.0%
*-commutative7.0%
+-commutative7.0%
associate-/l/7.0%
associate-*l/7.0%
Simplified6.8%
Taylor expanded in alpha around inf 96.9%
Taylor expanded in beta around 0 99.9%
associate--l+99.9%
associate--l+99.9%
associate-*r/99.9%
mul-1-neg99.9%
associate-*r/99.9%
metadata-eval99.9%
associate-*r/99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in alpha around inf 99.1%
if -0.999999949999999971 < (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) Initial program 99.8%
Final simplification99.6%
(FPCore (alpha beta) :precision binary64 (if (<= alpha 67000000000000.0) (+ 0.5 (* (- alpha beta) (/ -0.5 (+ beta (+ alpha 2.0))))) (/ (+ beta 1.0) alpha)))
double code(double alpha, double beta) {
double tmp;
if (alpha <= 67000000000000.0) {
tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + (alpha + 2.0))));
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (alpha <= 67000000000000.0d0) then
tmp = 0.5d0 + ((alpha - beta) * ((-0.5d0) / (beta + (alpha + 2.0d0))))
else
tmp = (beta + 1.0d0) / alpha
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (alpha <= 67000000000000.0) {
tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + (alpha + 2.0))));
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if alpha <= 67000000000000.0: tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + (alpha + 2.0)))) else: tmp = (beta + 1.0) / alpha return tmp
function code(alpha, beta) tmp = 0.0 if (alpha <= 67000000000000.0) tmp = Float64(0.5 + Float64(Float64(alpha - beta) * Float64(-0.5 / Float64(beta + Float64(alpha + 2.0))))); else tmp = Float64(Float64(beta + 1.0) / alpha); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (alpha <= 67000000000000.0) tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + (alpha + 2.0)))); else tmp = (beta + 1.0) / alpha; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[alpha, 67000000000000.0], N[(0.5 + N[(N[(alpha - beta), $MachinePrecision] * N[(-0.5 / N[(beta + N[(alpha + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(beta + 1.0), $MachinePrecision] / alpha), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 67000000000000:\\
\;\;\;\;0.5 + \left(\alpha - \beta\right) \cdot \frac{-0.5}{\beta + \left(\alpha + 2\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\beta + 1}{\alpha}\\
\end{array}
\end{array}
if alpha < 6.7e13Initial program 99.5%
+-commutative99.5%
sub-neg99.5%
+-commutative99.5%
neg-sub099.5%
associate-+l-99.5%
sub0-neg99.5%
distribute-frac-neg99.5%
+-commutative99.5%
sub-neg99.5%
div-sub99.5%
sub-neg99.5%
metadata-eval99.5%
neg-mul-199.5%
*-commutative99.5%
+-commutative99.5%
associate-/l/99.5%
associate-*l/99.5%
Simplified99.4%
if 6.7e13 < alpha Initial program 22.1%
+-commutative22.1%
sub-neg22.1%
+-commutative22.1%
neg-sub022.1%
associate-+l-22.1%
sub0-neg22.1%
distribute-frac-neg22.1%
+-commutative22.1%
sub-neg22.1%
div-sub22.1%
sub-neg22.1%
metadata-eval22.1%
neg-mul-122.1%
*-commutative22.1%
+-commutative22.1%
associate-/l/22.1%
associate-*l/22.1%
Simplified21.9%
Taylor expanded in alpha around inf 80.9%
Taylor expanded in beta around 0 83.5%
associate--l+83.5%
associate--l+83.5%
associate-*r/83.5%
mul-1-neg83.5%
associate-*r/83.5%
metadata-eval83.5%
associate-*r/83.5%
metadata-eval83.5%
Simplified83.5%
Taylor expanded in alpha around inf 84.1%
Final simplification94.8%
(FPCore (alpha beta) :precision binary64 (if (<= alpha 20.0) (+ 0.5 (* (- alpha beta) (/ -0.5 (+ beta 2.0)))) (/ (+ beta 1.0) alpha)))
double code(double alpha, double beta) {
double tmp;
if (alpha <= 20.0) {
tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + 2.0)));
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (alpha <= 20.0d0) then
tmp = 0.5d0 + ((alpha - beta) * ((-0.5d0) / (beta + 2.0d0)))
else
tmp = (beta + 1.0d0) / alpha
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (alpha <= 20.0) {
tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + 2.0)));
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if alpha <= 20.0: tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + 2.0))) else: tmp = (beta + 1.0) / alpha return tmp
function code(alpha, beta) tmp = 0.0 if (alpha <= 20.0) tmp = Float64(0.5 + Float64(Float64(alpha - beta) * Float64(-0.5 / Float64(beta + 2.0)))); else tmp = Float64(Float64(beta + 1.0) / alpha); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (alpha <= 20.0) tmp = 0.5 + ((alpha - beta) * (-0.5 / (beta + 2.0))); else tmp = (beta + 1.0) / alpha; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[alpha, 20.0], N[(0.5 + N[(N[(alpha - beta), $MachinePrecision] * N[(-0.5 / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(beta + 1.0), $MachinePrecision] / alpha), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 20:\\
\;\;\;\;0.5 + \left(\alpha - \beta\right) \cdot \frac{-0.5}{\beta + 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\beta + 1}{\alpha}\\
\end{array}
\end{array}
if alpha < 20Initial program 100.0%
+-commutative100.0%
sub-neg100.0%
+-commutative100.0%
neg-sub0100.0%
associate-+l-100.0%
sub0-neg100.0%
distribute-frac-neg100.0%
+-commutative100.0%
sub-neg100.0%
div-sub100.0%
sub-neg100.0%
metadata-eval100.0%
neg-mul-1100.0%
*-commutative100.0%
+-commutative100.0%
associate-/l/100.0%
associate-*l/100.0%
Simplified100.0%
Taylor expanded in alpha around 0 99.6%
+-commutative99.6%
Simplified99.6%
if 20 < alpha Initial program 24.8%
+-commutative24.8%
sub-neg24.8%
+-commutative24.8%
neg-sub024.8%
associate-+l-24.8%
sub0-neg24.8%
distribute-frac-neg24.8%
+-commutative24.8%
sub-neg24.8%
div-sub24.8%
sub-neg24.8%
metadata-eval24.8%
neg-mul-124.8%
*-commutative24.8%
+-commutative24.8%
associate-/l/24.8%
associate-*l/24.8%
Simplified24.4%
Taylor expanded in alpha around inf 79.6%
Taylor expanded in beta around 0 82.1%
associate--l+82.1%
associate--l+82.1%
associate-*r/82.1%
mul-1-neg82.1%
associate-*r/82.1%
metadata-eval82.1%
associate-*r/82.1%
metadata-eval82.1%
Simplified82.1%
Taylor expanded in alpha around inf 82.0%
Final simplification94.0%
(FPCore (alpha beta) :precision binary64 (if (<= alpha 20.0) (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0) (/ (+ beta 1.0) alpha)))
double code(double alpha, double beta) {
double tmp;
if (alpha <= 20.0) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8) :: tmp
if (alpha <= 20.0d0) then
tmp = (1.0d0 + (beta / (beta + 2.0d0))) / 2.0d0
else
tmp = (beta + 1.0d0) / alpha
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (alpha <= 20.0) {
tmp = (1.0 + (beta / (beta + 2.0))) / 2.0;
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if alpha <= 20.0: tmp = (1.0 + (beta / (beta + 2.0))) / 2.0 else: tmp = (beta + 1.0) / alpha return tmp
function code(alpha, beta) tmp = 0.0 if (alpha <= 20.0) tmp = Float64(Float64(1.0 + Float64(beta / Float64(beta + 2.0))) / 2.0); else tmp = Float64(Float64(beta + 1.0) / alpha); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (alpha <= 20.0) tmp = (1.0 + (beta / (beta + 2.0))) / 2.0; else tmp = (beta + 1.0) / alpha; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[alpha, 20.0], N[(N[(1.0 + N[(beta / N[(beta + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[(beta + 1.0), $MachinePrecision] / alpha), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 20:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\beta + 1}{\alpha}\\
\end{array}
\end{array}
if alpha < 20Initial program 100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in alpha around 0 99.0%
+-commutative99.0%
Simplified99.0%
if 20 < alpha Initial program 24.8%
+-commutative24.8%
sub-neg24.8%
+-commutative24.8%
neg-sub024.8%
associate-+l-24.8%
sub0-neg24.8%
distribute-frac-neg24.8%
+-commutative24.8%
sub-neg24.8%
div-sub24.8%
sub-neg24.8%
metadata-eval24.8%
neg-mul-124.8%
*-commutative24.8%
+-commutative24.8%
associate-/l/24.8%
associate-*l/24.8%
Simplified24.4%
Taylor expanded in alpha around inf 79.6%
Taylor expanded in beta around 0 82.1%
associate--l+82.1%
associate--l+82.1%
associate-*r/82.1%
mul-1-neg82.1%
associate-*r/82.1%
metadata-eval82.1%
associate-*r/82.1%
metadata-eval82.1%
Simplified82.1%
Taylor expanded in alpha around inf 82.0%
Final simplification93.6%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.0) (+ 0.5 (* beta 0.25)) (- 1.0 (/ 1.0 beta))))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.0) {
tmp = 0.5 + (beta * 0.25);
} else {
tmp = 1.0 - (1.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.0d0) then
tmp = 0.5d0 + (beta * 0.25d0)
else
tmp = 1.0d0 - (1.0d0 / beta)
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.0) {
tmp = 0.5 + (beta * 0.25);
} else {
tmp = 1.0 - (1.0 / beta);
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.0: tmp = 0.5 + (beta * 0.25) else: tmp = 1.0 - (1.0 / beta) return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.0) tmp = Float64(0.5 + Float64(beta * 0.25)); else tmp = Float64(1.0 - Float64(1.0 / beta)); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.0) tmp = 0.5 + (beta * 0.25); else tmp = 1.0 - (1.0 / beta); end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.0], N[(0.5 + N[(beta * 0.25), $MachinePrecision]), $MachinePrecision], N[(1.0 - N[(1.0 / beta), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2:\\
\;\;\;\;0.5 + \beta \cdot 0.25\\
\mathbf{else}:\\
\;\;\;\;1 - \frac{1}{\beta}\\
\end{array}
\end{array}
if beta < 2Initial program 69.9%
+-commutative69.9%
Simplified69.9%
Taylor expanded in alpha around 0 67.4%
+-commutative67.4%
Simplified67.4%
Taylor expanded in beta around 0 66.4%
*-commutative66.4%
Simplified66.4%
if 2 < beta Initial program 86.3%
+-commutative86.3%
Simplified86.3%
Taylor expanded in alpha around 0 84.3%
+-commutative84.3%
Simplified84.3%
Taylor expanded in beta around inf 84.3%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.0) (+ 0.5 (* beta 0.25)) 1.0))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.0) {
tmp = 0.5 + (beta * 0.25);
} else {
tmp = 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.0d0) then
tmp = 0.5d0 + (beta * 0.25d0)
else
tmp = 1.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.0) {
tmp = 0.5 + (beta * 0.25);
} else {
tmp = 1.0;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.0: tmp = 0.5 + (beta * 0.25) else: tmp = 1.0 return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.0) tmp = Float64(0.5 + Float64(beta * 0.25)); else tmp = 1.0; end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.0) tmp = 0.5 + (beta * 0.25); else tmp = 1.0; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.0], N[(0.5 + N[(beta * 0.25), $MachinePrecision]), $MachinePrecision], 1.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2:\\
\;\;\;\;0.5 + \beta \cdot 0.25\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if beta < 2Initial program 69.9%
+-commutative69.9%
Simplified69.9%
Taylor expanded in alpha around 0 67.4%
+-commutative67.4%
Simplified67.4%
Taylor expanded in beta around 0 66.4%
*-commutative66.4%
Simplified66.4%
if 2 < beta Initial program 86.3%
+-commutative86.3%
sub-neg86.3%
+-commutative86.3%
neg-sub086.3%
associate-+l-86.3%
sub0-neg86.3%
distribute-frac-neg86.3%
+-commutative86.3%
sub-neg86.3%
div-sub86.3%
sub-neg86.3%
metadata-eval86.3%
neg-mul-186.3%
*-commutative86.3%
+-commutative86.3%
associate-/l/86.3%
associate-*l/86.3%
Simplified86.2%
+-commutative86.2%
*-commutative86.2%
fma-define86.2%
associate-+r+86.2%
+-commutative86.2%
associate-+l+86.2%
Applied egg-rr86.2%
Taylor expanded in beta around inf 84.2%
(FPCore (alpha beta) :precision binary64 (if (<= beta 2.0) 0.5 1.0))
double code(double alpha, double beta) {
double tmp;
if (beta <= 2.0) {
tmp = 0.5;
} else {
tmp = 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.0d0) then
tmp = 0.5d0
else
tmp = 1.0d0
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (beta <= 2.0) {
tmp = 0.5;
} else {
tmp = 1.0;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 2.0: tmp = 0.5 else: tmp = 1.0 return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 2.0) tmp = 0.5; else tmp = 1.0; end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 2.0) tmp = 0.5; else tmp = 1.0; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 2.0], 0.5, 1.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2:\\
\;\;\;\;0.5\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if beta < 2Initial program 69.9%
+-commutative69.9%
Simplified69.9%
Taylor expanded in alpha around 0 67.4%
+-commutative67.4%
Simplified67.4%
Taylor expanded in beta around 0 65.6%
if 2 < beta Initial program 86.3%
+-commutative86.3%
sub-neg86.3%
+-commutative86.3%
neg-sub086.3%
associate-+l-86.3%
sub0-neg86.3%
distribute-frac-neg86.3%
+-commutative86.3%
sub-neg86.3%
div-sub86.3%
sub-neg86.3%
metadata-eval86.3%
neg-mul-186.3%
*-commutative86.3%
+-commutative86.3%
associate-/l/86.3%
associate-*l/86.3%
Simplified86.2%
+-commutative86.2%
*-commutative86.2%
fma-define86.2%
associate-+r+86.2%
+-commutative86.2%
associate-+l+86.2%
Applied egg-rr86.2%
Taylor expanded in beta around inf 84.2%
(FPCore (alpha beta) :precision binary64 0.5)
double code(double alpha, double beta) {
return 0.5;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = 0.5d0
end function
public static double code(double alpha, double beta) {
return 0.5;
}
def code(alpha, beta): return 0.5
function code(alpha, beta) return 0.5 end
function tmp = code(alpha, beta) tmp = 0.5; end
code[alpha_, beta_] := 0.5
\begin{array}{l}
\\
0.5
\end{array}
Initial program 75.9%
+-commutative75.9%
Simplified75.9%
Taylor expanded in alpha around 0 73.6%
+-commutative73.6%
Simplified73.6%
Taylor expanded in beta around 0 47.7%
(FPCore (alpha beta) :precision binary64 0.0)
double code(double alpha, double beta) {
return 0.0;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = 0.0d0
end function
public static double code(double alpha, double beta) {
return 0.0;
}
def code(alpha, beta): return 0.0
function code(alpha, beta) return 0.0 end
function tmp = code(alpha, beta) tmp = 0.0; end
code[alpha_, beta_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 75.9%
+-commutative75.9%
sub-neg75.9%
+-commutative75.9%
neg-sub075.9%
associate-+l-75.9%
sub0-neg75.9%
distribute-frac-neg75.9%
+-commutative75.9%
sub-neg75.9%
div-sub75.9%
sub-neg75.9%
metadata-eval75.9%
neg-mul-175.9%
*-commutative75.9%
+-commutative75.9%
associate-/l/75.9%
associate-*l/75.9%
Simplified75.8%
Taylor expanded in alpha around inf 3.7%
metadata-eval3.7%
Applied egg-rr3.7%
herbie shell --seed 2024150
(FPCore (alpha beta)
:name "Octave 3.8, jcobi/1"
:precision binary64
:pre (and (> alpha -1.0) (> beta -1.0))
(/ (+ (/ (- beta alpha) (+ (+ alpha beta) 2.0)) 1.0) 2.0))