
(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 9 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
(let* ((t_0 (/ (- beta alpha) (+ (+ beta alpha) 2.0))))
(if (<= t_0 -0.9)
(/ (- (+ beta (* (+ beta 2.0) (/ (- -1.0 beta) alpha))) -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.9) {
tmp = ((beta + ((beta + 2.0) * ((-1.0 - beta) / alpha))) - -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.9d0)) then
tmp = ((beta + ((beta + 2.0d0) * (((-1.0d0) - beta) / alpha))) - (-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.9) {
tmp = ((beta + ((beta + 2.0) * ((-1.0 - beta) / alpha))) - -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.9: tmp = ((beta + ((beta + 2.0) * ((-1.0 - beta) / alpha))) - -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.9) tmp = Float64(Float64(Float64(beta + Float64(Float64(beta + 2.0) * Float64(Float64(-1.0 - beta) / alpha))) - -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.9) tmp = ((beta + ((beta + 2.0) * ((-1.0 - beta) / alpha))) - -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.9], N[(N[(N[(beta + N[(N[(beta + 2.0), $MachinePrecision] * N[(N[(-1.0 - beta), $MachinePrecision] / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - -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.9:\\
\;\;\;\;\frac{\left(\beta + \left(\beta + 2\right) \cdot \frac{-1 - \beta}{\alpha}\right) - -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.900000000000000022Initial program 6.6%
+-commutative6.6%
sub-neg6.6%
+-commutative6.6%
neg-sub06.6%
associate-+l-6.6%
sub0-neg6.6%
distribute-frac-neg6.6%
+-commutative6.6%
sub-neg6.6%
div-sub6.6%
sub-neg6.6%
metadata-eval6.6%
neg-mul-16.6%
*-commutative6.6%
+-commutative6.6%
associate-/l/6.6%
associate-*l/6.6%
Simplified6.6%
Taylor expanded in alpha around inf 96.2%
fma-define96.2%
neg-mul-196.2%
+-commutative96.2%
associate-/l*99.9%
+-commutative99.9%
neg-mul-199.9%
+-commutative99.9%
Simplified99.9%
Taylor expanded in alpha around -inf 96.2%
Simplified99.9%
if -0.900000000000000022 < (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) Initial program 100.0%
Final simplification100.0%
(FPCore (alpha beta) :precision binary64 (let* ((t_0 (/ (- beta alpha) (+ (+ beta alpha) 2.0)))) (if (<= t_0 -0.9) (/ (+ 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.9) {
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.9d0)) 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.9) {
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.9: 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.9) 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.9) 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.9], 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.9:\\
\;\;\;\;\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.900000000000000022Initial program 6.6%
+-commutative6.6%
sub-neg6.6%
+-commutative6.6%
neg-sub06.6%
associate-+l-6.6%
sub0-neg6.6%
distribute-frac-neg6.6%
+-commutative6.6%
sub-neg6.6%
div-sub6.6%
sub-neg6.6%
metadata-eval6.6%
neg-mul-16.6%
*-commutative6.6%
+-commutative6.6%
associate-/l/6.6%
associate-*l/6.6%
Simplified6.6%
Taylor expanded in alpha around inf 96.2%
fma-define96.2%
neg-mul-196.2%
+-commutative96.2%
associate-/l*99.9%
+-commutative99.9%
neg-mul-199.9%
+-commutative99.9%
Simplified99.9%
Taylor expanded in alpha around inf 99.3%
associate-*r/99.3%
distribute-lft-in99.3%
metadata-eval99.3%
associate-*r*99.3%
metadata-eval99.3%
*-lft-identity99.3%
+-commutative99.3%
Simplified99.3%
if -0.900000000000000022 < (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) #s(literal 2 binary64))) Initial program 100.0%
Final simplification99.8%
(FPCore (alpha beta)
:precision binary64
(let* ((t_0 (/ (- 1.0 (* alpha 0.5)) 2.0)))
(if (<= alpha 2.3e-133)
t_0
(if (<= alpha 1.5e-103)
1.0
(if (<= alpha 1.8) t_0 (/ (+ beta 1.0) alpha))))))
double code(double alpha, double beta) {
double t_0 = (1.0 - (alpha * 0.5)) / 2.0;
double tmp;
if (alpha <= 2.3e-133) {
tmp = t_0;
} else if (alpha <= 1.5e-103) {
tmp = 1.0;
} else if (alpha <= 1.8) {
tmp = t_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) :: t_0
real(8) :: tmp
t_0 = (1.0d0 - (alpha * 0.5d0)) / 2.0d0
if (alpha <= 2.3d-133) then
tmp = t_0
else if (alpha <= 1.5d-103) then
tmp = 1.0d0
else if (alpha <= 1.8d0) then
tmp = t_0
else
tmp = (beta + 1.0d0) / alpha
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double t_0 = (1.0 - (alpha * 0.5)) / 2.0;
double tmp;
if (alpha <= 2.3e-133) {
tmp = t_0;
} else if (alpha <= 1.5e-103) {
tmp = 1.0;
} else if (alpha <= 1.8) {
tmp = t_0;
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
def code(alpha, beta): t_0 = (1.0 - (alpha * 0.5)) / 2.0 tmp = 0 if alpha <= 2.3e-133: tmp = t_0 elif alpha <= 1.5e-103: tmp = 1.0 elif alpha <= 1.8: tmp = t_0 else: tmp = (beta + 1.0) / alpha return tmp
function code(alpha, beta) t_0 = Float64(Float64(1.0 - Float64(alpha * 0.5)) / 2.0) tmp = 0.0 if (alpha <= 2.3e-133) tmp = t_0; elseif (alpha <= 1.5e-103) tmp = 1.0; elseif (alpha <= 1.8) tmp = t_0; else tmp = Float64(Float64(beta + 1.0) / alpha); end return tmp end
function tmp_2 = code(alpha, beta) t_0 = (1.0 - (alpha * 0.5)) / 2.0; tmp = 0.0; if (alpha <= 2.3e-133) tmp = t_0; elseif (alpha <= 1.5e-103) tmp = 1.0; elseif (alpha <= 1.8) tmp = t_0; else tmp = (beta + 1.0) / alpha; end tmp_2 = tmp; end
code[alpha_, beta_] := Block[{t$95$0 = N[(N[(1.0 - N[(alpha * 0.5), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]}, If[LessEqual[alpha, 2.3e-133], t$95$0, If[LessEqual[alpha, 1.5e-103], 1.0, If[LessEqual[alpha, 1.8], t$95$0, N[(N[(beta + 1.0), $MachinePrecision] / alpha), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1 - \alpha \cdot 0.5}{2}\\
\mathbf{if}\;\alpha \leq 2.3 \cdot 10^{-133}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\alpha \leq 1.5 \cdot 10^{-103}:\\
\;\;\;\;1\\
\mathbf{elif}\;\alpha \leq 1.8:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{\beta + 1}{\alpha}\\
\end{array}
\end{array}
if alpha < 2.3e-133 or 1.5e-103 < alpha < 1.80000000000000004Initial program 100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in beta around 0 75.7%
Taylor expanded in alpha around 0 75.1%
*-commutative75.1%
Simplified75.1%
if 2.3e-133 < alpha < 1.5e-103Initial 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 beta around inf 77.8%
if 1.80000000000000004 < alpha Initial program 17.0%
+-commutative17.0%
sub-neg17.0%
+-commutative17.0%
neg-sub017.0%
associate-+l-17.0%
sub0-neg17.0%
distribute-frac-neg17.0%
+-commutative17.0%
sub-neg17.0%
div-sub17.0%
sub-neg17.0%
metadata-eval17.0%
neg-mul-117.0%
*-commutative17.0%
+-commutative17.0%
associate-/l/17.0%
associate-*l/17.0%
Simplified17.0%
Taylor expanded in alpha around inf 85.9%
fma-define85.9%
neg-mul-185.9%
+-commutative85.9%
associate-/l*89.2%
+-commutative89.2%
neg-mul-189.2%
+-commutative89.2%
Simplified89.2%
Taylor expanded in alpha around inf 89.3%
associate-*r/89.3%
distribute-lft-in89.3%
metadata-eval89.3%
associate-*r*89.3%
metadata-eval89.3%
*-lft-identity89.3%
+-commutative89.3%
Simplified89.3%
Final simplification80.2%
(FPCore (alpha beta)
:precision binary64
(if (<= alpha 2.3e-133)
0.5
(if (<= alpha 1.5e-103)
1.0
(if (<= alpha 5.6) 0.5 (/ (+ beta 1.0) alpha)))))
double code(double alpha, double beta) {
double tmp;
if (alpha <= 2.3e-133) {
tmp = 0.5;
} else if (alpha <= 1.5e-103) {
tmp = 1.0;
} else if (alpha <= 5.6) {
tmp = 0.5;
} 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 <= 2.3d-133) then
tmp = 0.5d0
else if (alpha <= 1.5d-103) then
tmp = 1.0d0
else if (alpha <= 5.6d0) then
tmp = 0.5d0
else
tmp = (beta + 1.0d0) / alpha
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (alpha <= 2.3e-133) {
tmp = 0.5;
} else if (alpha <= 1.5e-103) {
tmp = 1.0;
} else if (alpha <= 5.6) {
tmp = 0.5;
} else {
tmp = (beta + 1.0) / alpha;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if alpha <= 2.3e-133: tmp = 0.5 elif alpha <= 1.5e-103: tmp = 1.0 elif alpha <= 5.6: tmp = 0.5 else: tmp = (beta + 1.0) / alpha return tmp
function code(alpha, beta) tmp = 0.0 if (alpha <= 2.3e-133) tmp = 0.5; elseif (alpha <= 1.5e-103) tmp = 1.0; elseif (alpha <= 5.6) tmp = 0.5; else tmp = Float64(Float64(beta + 1.0) / alpha); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (alpha <= 2.3e-133) tmp = 0.5; elseif (alpha <= 1.5e-103) tmp = 1.0; elseif (alpha <= 5.6) tmp = 0.5; else tmp = (beta + 1.0) / alpha; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[alpha, 2.3e-133], 0.5, If[LessEqual[alpha, 1.5e-103], 1.0, If[LessEqual[alpha, 5.6], 0.5, N[(N[(beta + 1.0), $MachinePrecision] / alpha), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 2.3 \cdot 10^{-133}:\\
\;\;\;\;0.5\\
\mathbf{elif}\;\alpha \leq 1.5 \cdot 10^{-103}:\\
\;\;\;\;1\\
\mathbf{elif}\;\alpha \leq 5.6:\\
\;\;\;\;0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{\beta + 1}{\alpha}\\
\end{array}
\end{array}
if alpha < 2.3e-133 or 1.5e-103 < alpha < 5.5999999999999996Initial program 100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in beta around 0 75.7%
Taylor expanded in alpha around 0 73.4%
if 2.3e-133 < alpha < 1.5e-103Initial 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 beta around inf 77.8%
if 5.5999999999999996 < alpha Initial program 17.0%
+-commutative17.0%
sub-neg17.0%
+-commutative17.0%
neg-sub017.0%
associate-+l-17.0%
sub0-neg17.0%
distribute-frac-neg17.0%
+-commutative17.0%
sub-neg17.0%
div-sub17.0%
sub-neg17.0%
metadata-eval17.0%
neg-mul-117.0%
*-commutative17.0%
+-commutative17.0%
associate-/l/17.0%
associate-*l/17.0%
Simplified17.0%
Taylor expanded in alpha around inf 85.9%
fma-define85.9%
neg-mul-185.9%
+-commutative85.9%
associate-/l*89.2%
+-commutative89.2%
neg-mul-189.2%
+-commutative89.2%
Simplified89.2%
Taylor expanded in alpha around inf 89.3%
associate-*r/89.3%
distribute-lft-in89.3%
metadata-eval89.3%
associate-*r*89.3%
metadata-eval89.3%
*-lft-identity89.3%
+-commutative89.3%
Simplified89.3%
Final simplification79.2%
(FPCore (alpha beta) :precision binary64 (if (<= alpha 2.3e-133) 0.5 (if (<= alpha 1.8e-103) 1.0 (if (<= alpha 0.9) 0.5 (/ 1.0 alpha)))))
double code(double alpha, double beta) {
double tmp;
if (alpha <= 2.3e-133) {
tmp = 0.5;
} else if (alpha <= 1.8e-103) {
tmp = 1.0;
} else if (alpha <= 0.9) {
tmp = 0.5;
} else {
tmp = 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 <= 2.3d-133) then
tmp = 0.5d0
else if (alpha <= 1.8d-103) then
tmp = 1.0d0
else if (alpha <= 0.9d0) then
tmp = 0.5d0
else
tmp = 1.0d0 / alpha
end if
code = tmp
end function
public static double code(double alpha, double beta) {
double tmp;
if (alpha <= 2.3e-133) {
tmp = 0.5;
} else if (alpha <= 1.8e-103) {
tmp = 1.0;
} else if (alpha <= 0.9) {
tmp = 0.5;
} else {
tmp = 1.0 / alpha;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if alpha <= 2.3e-133: tmp = 0.5 elif alpha <= 1.8e-103: tmp = 1.0 elif alpha <= 0.9: tmp = 0.5 else: tmp = 1.0 / alpha return tmp
function code(alpha, beta) tmp = 0.0 if (alpha <= 2.3e-133) tmp = 0.5; elseif (alpha <= 1.8e-103) tmp = 1.0; elseif (alpha <= 0.9) tmp = 0.5; else tmp = Float64(1.0 / alpha); end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (alpha <= 2.3e-133) tmp = 0.5; elseif (alpha <= 1.8e-103) tmp = 1.0; elseif (alpha <= 0.9) tmp = 0.5; else tmp = 1.0 / alpha; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[alpha, 2.3e-133], 0.5, If[LessEqual[alpha, 1.8e-103], 1.0, If[LessEqual[alpha, 0.9], 0.5, N[(1.0 / alpha), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\alpha \leq 2.3 \cdot 10^{-133}:\\
\;\;\;\;0.5\\
\mathbf{elif}\;\alpha \leq 1.8 \cdot 10^{-103}:\\
\;\;\;\;1\\
\mathbf{elif}\;\alpha \leq 0.9:\\
\;\;\;\;0.5\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\alpha}\\
\end{array}
\end{array}
if alpha < 2.3e-133 or 1.7999999999999999e-103 < alpha < 0.900000000000000022Initial program 100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in beta around 0 75.7%
Taylor expanded in alpha around 0 73.4%
if 2.3e-133 < alpha < 1.7999999999999999e-103Initial 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 beta around inf 77.8%
if 0.900000000000000022 < alpha Initial program 17.0%
+-commutative17.0%
sub-neg17.0%
+-commutative17.0%
neg-sub017.0%
associate-+l-17.0%
sub0-neg17.0%
distribute-frac-neg17.0%
+-commutative17.0%
sub-neg17.0%
div-sub17.0%
sub-neg17.0%
metadata-eval17.0%
neg-mul-117.0%
*-commutative17.0%
+-commutative17.0%
associate-/l/17.0%
associate-*l/17.0%
Simplified17.0%
Taylor expanded in alpha around inf 85.9%
fma-define85.9%
neg-mul-185.9%
+-commutative85.9%
associate-/l*89.2%
+-commutative89.2%
neg-mul-189.2%
+-commutative89.2%
Simplified89.2%
Taylor expanded in beta around 0 74.6%
associate-*r/74.6%
metadata-eval74.6%
Simplified74.6%
Taylor expanded in alpha around inf 74.5%
Final simplification74.0%
(FPCore (alpha beta) :precision binary64 (if (<= alpha 330000000000.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 <= 330000000000.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 <= 330000000000.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 <= 330000000000.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 <= 330000000000.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 <= 330000000000.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 <= 330000000000.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, 330000000000.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 330000000000:\\
\;\;\;\;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 < 3.3e11Initial 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%
if 3.3e11 < alpha Initial program 16.0%
+-commutative16.0%
sub-neg16.0%
+-commutative16.0%
neg-sub016.0%
associate-+l-16.0%
sub0-neg16.0%
distribute-frac-neg16.0%
+-commutative16.0%
sub-neg16.0%
div-sub16.0%
sub-neg16.0%
metadata-eval16.0%
neg-mul-116.0%
*-commutative16.0%
+-commutative16.0%
associate-/l/16.0%
associate-*l/16.0%
Simplified16.1%
Taylor expanded in alpha around inf 86.6%
fma-define86.6%
neg-mul-186.6%
+-commutative86.6%
associate-/l*90.0%
+-commutative90.0%
neg-mul-190.0%
+-commutative90.0%
Simplified90.0%
Taylor expanded in alpha around inf 90.0%
associate-*r/90.0%
distribute-lft-in90.0%
metadata-eval90.0%
associate-*r*90.0%
metadata-eval90.0%
*-lft-identity90.0%
+-commutative90.0%
Simplified90.0%
Final simplification96.5%
(FPCore (alpha beta) :precision binary64 (if (<= alpha 13.6) (/ (+ 1.0 (/ beta (+ beta 2.0))) 2.0) (/ (+ beta 1.0) alpha)))
double code(double alpha, double beta) {
double tmp;
if (alpha <= 13.6) {
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 <= 13.6d0) 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 <= 13.6) {
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 <= 13.6: 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 <= 13.6) 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 <= 13.6) 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, 13.6], 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 13.6:\\
\;\;\;\;\frac{1 + \frac{\beta}{\beta + 2}}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\beta + 1}{\alpha}\\
\end{array}
\end{array}
if alpha < 13.5999999999999996Initial program 100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in alpha around 0 97.9%
+-commutative97.9%
+-commutative97.9%
Simplified97.9%
if 13.5999999999999996 < alpha Initial program 17.0%
+-commutative17.0%
sub-neg17.0%
+-commutative17.0%
neg-sub017.0%
associate-+l-17.0%
sub0-neg17.0%
distribute-frac-neg17.0%
+-commutative17.0%
sub-neg17.0%
div-sub17.0%
sub-neg17.0%
metadata-eval17.0%
neg-mul-117.0%
*-commutative17.0%
+-commutative17.0%
associate-/l/17.0%
associate-*l/17.0%
Simplified17.0%
Taylor expanded in alpha around inf 85.9%
fma-define85.9%
neg-mul-185.9%
+-commutative85.9%
associate-/l*89.2%
+-commutative89.2%
neg-mul-189.2%
+-commutative89.2%
Simplified89.2%
Taylor expanded in alpha around inf 89.3%
associate-*r/89.3%
distribute-lft-in89.3%
metadata-eval89.3%
associate-*r*89.3%
metadata-eval89.3%
*-lft-identity89.3%
+-commutative89.3%
Simplified89.3%
Final simplification94.9%
(FPCore (alpha beta) :precision binary64 (if (<= beta 12.0) 0.5 1.0))
double code(double alpha, double beta) {
double tmp;
if (beta <= 12.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 <= 12.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 <= 12.0) {
tmp = 0.5;
} else {
tmp = 1.0;
}
return tmp;
}
def code(alpha, beta): tmp = 0 if beta <= 12.0: tmp = 0.5 else: tmp = 1.0 return tmp
function code(alpha, beta) tmp = 0.0 if (beta <= 12.0) tmp = 0.5; else tmp = 1.0; end return tmp end
function tmp_2 = code(alpha, beta) tmp = 0.0; if (beta <= 12.0) tmp = 0.5; else tmp = 1.0; end tmp_2 = tmp; end
code[alpha_, beta_] := If[LessEqual[beta, 12.0], 0.5, 1.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 12:\\
\;\;\;\;0.5\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if beta < 12Initial program 65.4%
+-commutative65.4%
Simplified65.4%
Taylor expanded in beta around 0 63.6%
Taylor expanded in alpha around 0 61.0%
if 12 < beta Initial program 84.3%
+-commutative84.3%
sub-neg84.3%
+-commutative84.3%
neg-sub084.3%
associate-+l-84.3%
sub0-neg84.3%
distribute-frac-neg84.3%
+-commutative84.3%
sub-neg84.3%
div-sub84.3%
sub-neg84.3%
metadata-eval84.3%
neg-mul-184.3%
*-commutative84.3%
+-commutative84.3%
associate-/l/84.3%
associate-*l/84.3%
Simplified84.5%
Taylor expanded in beta around inf 81.4%
Final simplification66.8%
(FPCore (alpha beta) :precision binary64 1.0)
double code(double alpha, double beta) {
return 1.0;
}
real(8) function code(alpha, beta)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
code = 1.0d0
end function
public static double code(double alpha, double beta) {
return 1.0;
}
def code(alpha, beta): return 1.0
function code(alpha, beta) return 1.0 end
function tmp = code(alpha, beta) tmp = 1.0; end
code[alpha_, beta_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 70.8%
+-commutative70.8%
sub-neg70.8%
+-commutative70.8%
neg-sub070.8%
associate-+l-70.8%
sub0-neg70.8%
distribute-frac-neg70.8%
+-commutative70.8%
sub-neg70.8%
div-sub70.8%
sub-neg70.8%
metadata-eval70.8%
neg-mul-170.8%
*-commutative70.8%
+-commutative70.8%
associate-/l/70.8%
associate-*l/70.8%
Simplified70.8%
Taylor expanded in beta around inf 33.0%
Final simplification33.0%
herbie shell --seed 2024095
(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))