
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (* i (+ (+ alpha beta) i)))
(t_1 (+ (+ alpha beta) (* 2.0 i)))
(t_2 (* t_1 t_1)))
(/ (/ (* t_0 (+ (* beta alpha) t_0)) t_2) (- t_2 1.0))))
double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
t_0 = i * ((alpha + beta) + i)
t_1 = (alpha + beta) + (2.0d0 * i)
t_2 = t_1 * t_1
code = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0d0)
end function
public static double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
def code(alpha, beta, i): t_0 = i * ((alpha + beta) + i) t_1 = (alpha + beta) + (2.0 * i) t_2 = t_1 * t_1 return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0)
function code(alpha, beta, i) t_0 = Float64(i * Float64(Float64(alpha + beta) + i)) t_1 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_2 = Float64(t_1 * t_1) return Float64(Float64(Float64(t_0 * Float64(Float64(beta * alpha) + t_0)) / t_2) / Float64(t_2 - 1.0)) end
function tmp = code(alpha, beta, i) t_0 = i * ((alpha + beta) + i); t_1 = (alpha + beta) + (2.0 * i); t_2 = t_1 * t_1; tmp = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0); end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i * N[(N[(alpha + beta), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * t$95$1), $MachinePrecision]}, N[(N[(N[(t$95$0 * N[(N[(beta * alpha), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] / N[(t$95$2 - 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i \cdot \left(\left(\alpha + \beta\right) + i\right)\\
t_1 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_2 := t_1 \cdot t_1\\
\frac{\frac{t_0 \cdot \left(\beta \cdot \alpha + t_0\right)}{t_2}}{t_2 - 1}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 20 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (* i (+ (+ alpha beta) i)))
(t_1 (+ (+ alpha beta) (* 2.0 i)))
(t_2 (* t_1 t_1)))
(/ (/ (* t_0 (+ (* beta alpha) t_0)) t_2) (- t_2 1.0))))
double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
t_0 = i * ((alpha + beta) + i)
t_1 = (alpha + beta) + (2.0d0 * i)
t_2 = t_1 * t_1
code = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0d0)
end function
public static double code(double alpha, double beta, double i) {
double t_0 = i * ((alpha + beta) + i);
double t_1 = (alpha + beta) + (2.0 * i);
double t_2 = t_1 * t_1;
return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0);
}
def code(alpha, beta, i): t_0 = i * ((alpha + beta) + i) t_1 = (alpha + beta) + (2.0 * i) t_2 = t_1 * t_1 return ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0)
function code(alpha, beta, i) t_0 = Float64(i * Float64(Float64(alpha + beta) + i)) t_1 = Float64(Float64(alpha + beta) + Float64(2.0 * i)) t_2 = Float64(t_1 * t_1) return Float64(Float64(Float64(t_0 * Float64(Float64(beta * alpha) + t_0)) / t_2) / Float64(t_2 - 1.0)) end
function tmp = code(alpha, beta, i) t_0 = i * ((alpha + beta) + i); t_1 = (alpha + beta) + (2.0 * i); t_2 = t_1 * t_1; tmp = ((t_0 * ((beta * alpha) + t_0)) / t_2) / (t_2 - 1.0); end
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i * N[(N[(alpha + beta), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(alpha + beta), $MachinePrecision] + N[(2.0 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * t$95$1), $MachinePrecision]}, N[(N[(N[(t$95$0 * N[(N[(beta * alpha), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] / N[(t$95$2 - 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := i \cdot \left(\left(\alpha + \beta\right) + i\right)\\
t_1 := \left(\alpha + \beta\right) + 2 \cdot i\\
t_2 := t_1 \cdot t_1\\
\frac{\frac{t_0 \cdot \left(\beta \cdot \alpha + t_0\right)}{t_2}}{t_2 - 1}
\end{array}
\end{array}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (pow (+ beta i) 2.0))
(t_1 (+ (+ beta alpha) (* i 2.0)))
(t_2 (pow (fma i 2.0 beta) 2.0)))
(if (<= beta 3.7e+63)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(* (/ (* i i) t_2) (log (exp (/ t_0 (+ -1.0 t_2)))))
(if (<= beta 2.6e+98)
0.0625
(if (<= beta 1.75e+141)
(/
(/
(* i i)
(/ (fma 4.0 (* beta i) (fma 4.0 (* i i) (* beta beta))) t_0))
(+ -1.0 (* t_1 t_1)))
(if (<= beta 6.5e+170)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = pow((beta + i), 2.0);
double t_1 = (beta + alpha) + (i * 2.0);
double t_2 = pow(fma(i, 2.0, beta), 2.0);
double tmp;
if (beta <= 3.7e+63) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = ((i * i) / t_2) * log(exp((t_0 / (-1.0 + t_2))));
} else if (beta <= 2.6e+98) {
tmp = 0.0625;
} else if (beta <= 1.75e+141) {
tmp = ((i * i) / (fma(4.0, (beta * i), fma(4.0, (i * i), (beta * beta))) / t_0)) / (-1.0 + (t_1 * t_1));
} else if (beta <= 6.5e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(beta + i) ^ 2.0 t_1 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) t_2 = fma(i, 2.0, beta) ^ 2.0 tmp = 0.0 if (beta <= 3.7e+63) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(i * i) / t_2) * log(exp(Float64(t_0 / Float64(-1.0 + t_2))))); elseif (beta <= 2.6e+98) tmp = 0.0625; elseif (beta <= 1.75e+141) tmp = Float64(Float64(Float64(i * i) / Float64(fma(4.0, Float64(beta * i), fma(4.0, Float64(i * i), Float64(beta * beta))) / t_0)) / Float64(-1.0 + Float64(t_1 * t_1))); elseif (beta <= 6.5e+170) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[Power[N[(beta + i), $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$1 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(i * 2.0 + beta), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[beta, 3.7e+63], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(i * i), $MachinePrecision] / t$95$2), $MachinePrecision] * N[Log[N[Exp[N[(t$95$0 / N[(-1.0 + t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 2.6e+98], 0.0625, If[LessEqual[beta, 1.75e+141], N[(N[(N[(i * i), $MachinePrecision] / N[(N[(4.0 * N[(beta * i), $MachinePrecision] + N[(4.0 * N[(i * i), $MachinePrecision] + N[(beta * beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision] / N[(-1.0 + N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 6.5e+170], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := {\left(\beta + i\right)}^{2}\\
t_1 := \left(\beta + \alpha\right) + i \cdot 2\\
t_2 := {\left(\mathsf{fma}\left(i, 2, \beta\right)\right)}^{2}\\
\mathbf{if}\;\beta \leq 3.7 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i \cdot i}{t_2} \cdot \log \left(e^{\frac{t_0}{-1 + t_2}}\right)\\
\mathbf{elif}\;\beta \leq 2.6 \cdot 10^{+98}:\\
\;\;\;\;0.0625\\
\mathbf{elif}\;\beta \leq 1.75 \cdot 10^{+141}:\\
\;\;\;\;\frac{\frac{i \cdot i}{\frac{\mathsf{fma}\left(4, \beta \cdot i, \mathsf{fma}\left(4, i \cdot i, \beta \cdot \beta\right)\right)}{t_0}}}{-1 + t_1 \cdot t_1}\\
\mathbf{elif}\;\beta \leq 6.5 \cdot 10^{+170}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 3.69999999999999968e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
if 3.69999999999999968e63 < beta < 3.2999999999999999e69Initial program 74.1%
associate-/l/74.1%
associate-*l*74.1%
times-frac73.7%
Simplified73.7%
Taylor expanded in alpha around 0 75.1%
times-frac75.3%
unpow275.3%
+-commutative75.3%
*-commutative75.3%
fma-udef75.3%
sub-neg75.3%
+-commutative75.3%
*-commutative75.3%
fma-udef75.3%
metadata-eval75.3%
Simplified75.3%
add-log-exp75.9%
+-commutative75.9%
Applied egg-rr75.9%
if 3.2999999999999999e69 < beta < 2.6e98Initial program 0.8%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.8%
Simplified27.0%
Taylor expanded in i around inf 74.4%
if 2.6e98 < beta < 1.75e141Initial program 15.9%
Taylor expanded in alpha around 0 15.9%
associate-/l*84.9%
unpow284.9%
+-commutative84.9%
*-commutative84.9%
fma-udef84.9%
Simplified84.9%
Taylor expanded in i around 0 85.3%
fma-def85.3%
fma-def85.3%
unpow285.3%
unpow285.3%
Simplified85.3%
if 1.75e141 < beta < 6.5e170Initial program 0.1%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.1%
Simplified8.8%
Taylor expanded in i around inf 84.4%
Taylor expanded in alpha around 0 76.2%
if 6.5e170 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification76.6%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (fma i 2.0 (+ beta alpha))) (t_1 (+ (+ beta alpha) (* i 2.0))))
(if (<= beta 4.2e+58)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(*
(/ i (fma t_0 t_0 -1.0))
(/
(+
(+ (* i (pow (+ i alpha) 2.0)) (* (* beta beta) (+ i alpha)))
(* beta (+ (* i (+ i alpha)) (* (+ i alpha) (+ i alpha)))))
(* t_0 t_0)))
(if (<= beta 1.7e+97)
0.0625
(if (<= beta 1.6e+141)
(/
(/
(* i i)
(/
(fma 4.0 (* beta i) (fma 4.0 (* i i) (* beta beta)))
(pow (+ beta i) 2.0)))
(+ -1.0 (* t_1 t_1)))
(if (<= beta 6.1e+170)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = fma(i, 2.0, (beta + alpha));
double t_1 = (beta + alpha) + (i * 2.0);
double tmp;
if (beta <= 4.2e+58) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = (i / fma(t_0, t_0, -1.0)) * ((((i * pow((i + alpha), 2.0)) + ((beta * beta) * (i + alpha))) + (beta * ((i * (i + alpha)) + ((i + alpha) * (i + alpha))))) / (t_0 * t_0));
} else if (beta <= 1.7e+97) {
tmp = 0.0625;
} else if (beta <= 1.6e+141) {
tmp = ((i * i) / (fma(4.0, (beta * i), fma(4.0, (i * i), (beta * beta))) / pow((beta + i), 2.0))) / (-1.0 + (t_1 * t_1));
} else if (beta <= 6.1e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = fma(i, 2.0, Float64(beta + alpha)) t_1 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) tmp = 0.0 if (beta <= 4.2e+58) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(i / fma(t_0, t_0, -1.0)) * Float64(Float64(Float64(Float64(i * (Float64(i + alpha) ^ 2.0)) + Float64(Float64(beta * beta) * Float64(i + alpha))) + Float64(beta * Float64(Float64(i * Float64(i + alpha)) + Float64(Float64(i + alpha) * Float64(i + alpha))))) / Float64(t_0 * t_0))); elseif (beta <= 1.7e+97) tmp = 0.0625; elseif (beta <= 1.6e+141) tmp = Float64(Float64(Float64(i * i) / Float64(fma(4.0, Float64(beta * i), fma(4.0, Float64(i * i), Float64(beta * beta))) / (Float64(beta + i) ^ 2.0))) / Float64(-1.0 + Float64(t_1 * t_1))); elseif (beta <= 6.1e+170) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i * 2.0 + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 4.2e+58], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(i / N[(t$95$0 * t$95$0 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(i * N[Power[N[(i + alpha), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * N[(i + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(beta * N[(N[(i * N[(i + alpha), $MachinePrecision]), $MachinePrecision] + N[(N[(i + alpha), $MachinePrecision] * N[(i + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 1.7e+97], 0.0625, If[LessEqual[beta, 1.6e+141], N[(N[(N[(i * i), $MachinePrecision] / N[(N[(4.0 * N[(beta * i), $MachinePrecision] + N[(4.0 * N[(i * i), $MachinePrecision] + N[(beta * beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[(beta + i), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(-1.0 + N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 6.1e+170], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(i, 2, \beta + \alpha\right)\\
t_1 := \left(\beta + \alpha\right) + i \cdot 2\\
\mathbf{if}\;\beta \leq 4.2 \cdot 10^{+58}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i}{\mathsf{fma}\left(t_0, t_0, -1\right)} \cdot \frac{\left(i \cdot {\left(i + \alpha\right)}^{2} + \left(\beta \cdot \beta\right) \cdot \left(i + \alpha\right)\right) + \beta \cdot \left(i \cdot \left(i + \alpha\right) + \left(i + \alpha\right) \cdot \left(i + \alpha\right)\right)}{t_0 \cdot t_0}\\
\mathbf{elif}\;\beta \leq 1.7 \cdot 10^{+97}:\\
\;\;\;\;0.0625\\
\mathbf{elif}\;\beta \leq 1.6 \cdot 10^{+141}:\\
\;\;\;\;\frac{\frac{i \cdot i}{\frac{\mathsf{fma}\left(4, \beta \cdot i, \mathsf{fma}\left(4, i \cdot i, \beta \cdot \beta\right)\right)}{{\left(\beta + i\right)}^{2}}}}{-1 + t_1 \cdot t_1}\\
\mathbf{elif}\;\beta \leq 6.1 \cdot 10^{+170}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.20000000000000024e58Initial program 21.8%
associate-/l/20.5%
associate-*l*20.4%
times-frac26.6%
Simplified49.9%
Taylor expanded in alpha around 0 18.5%
times-frac41.1%
unpow241.1%
+-commutative41.1%
*-commutative41.1%
fma-udef41.1%
sub-neg41.1%
+-commutative41.1%
*-commutative41.1%
fma-udef41.1%
metadata-eval41.1%
Simplified41.1%
Taylor expanded in i around inf 77.4%
associate--l+77.4%
associate-*r/77.4%
unpow277.4%
unpow277.4%
associate-*r/77.4%
Simplified77.4%
if 4.20000000000000024e58 < beta < 3.2999999999999999e69Initial program 59.3%
associate-/l/59.3%
associate-*l*59.3%
times-frac59.0%
Simplified59.0%
Taylor expanded in beta around -inf 59.4%
+-commutative59.4%
mul-1-neg59.4%
unsub-neg59.4%
Simplified59.4%
if 3.2999999999999999e69 < beta < 1.70000000000000005e97Initial program 0.8%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.8%
Simplified27.0%
Taylor expanded in i around inf 74.4%
if 1.70000000000000005e97 < beta < 1.60000000000000009e141Initial program 15.9%
Taylor expanded in alpha around 0 15.9%
associate-/l*84.9%
unpow284.9%
+-commutative84.9%
*-commutative84.9%
fma-udef84.9%
Simplified84.9%
Taylor expanded in i around 0 85.3%
fma-def85.3%
fma-def85.3%
unpow285.3%
unpow285.3%
Simplified85.3%
if 1.60000000000000009e141 < beta < 6.1000000000000004e170Initial program 0.1%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.1%
Simplified8.8%
Taylor expanded in i around inf 84.4%
Taylor expanded in alpha around 0 76.2%
if 6.1000000000000004e170 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification76.6%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ beta alpha) (* i 2.0)))
(t_1 (+ -1.0 (* t_0 t_0)))
(t_2 (pow (+ beta i) 2.0)))
(if (<= beta 4.1e+63)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(/ (/ (* t_2 (pow i 2.0)) (pow (+ beta (* i 2.0)) 2.0)) t_1)
(if (<= beta 4e+99)
0.0625
(if (<= beta 5.3e+141)
(/
(/
(* i i)
(/ (fma 4.0 (* beta i) (fma 4.0 (* i i) (* beta beta))) t_2))
t_1)
(if (<= beta 4.3e+170)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = (beta + alpha) + (i * 2.0);
double t_1 = -1.0 + (t_0 * t_0);
double t_2 = pow((beta + i), 2.0);
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = ((t_2 * pow(i, 2.0)) / pow((beta + (i * 2.0)), 2.0)) / t_1;
} else if (beta <= 4e+99) {
tmp = 0.0625;
} else if (beta <= 5.3e+141) {
tmp = ((i * i) / (fma(4.0, (beta * i), fma(4.0, (i * i), (beta * beta))) / t_2)) / t_1;
} else if (beta <= 4.3e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) t_1 = Float64(-1.0 + Float64(t_0 * t_0)) t_2 = Float64(beta + i) ^ 2.0 tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(t_2 * (i ^ 2.0)) / (Float64(beta + Float64(i * 2.0)) ^ 2.0)) / t_1); elseif (beta <= 4e+99) tmp = 0.0625; elseif (beta <= 5.3e+141) tmp = Float64(Float64(Float64(i * i) / Float64(fma(4.0, Float64(beta * i), fma(4.0, Float64(i * i), Float64(beta * beta))) / t_2)) / t_1); elseif (beta <= 4.3e+170) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(-1.0 + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(beta + i), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(t$95$2 * N[Power[i, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[N[(beta + N[(i * 2.0), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[beta, 4e+99], 0.0625, If[LessEqual[beta, 5.3e+141], N[(N[(N[(i * i), $MachinePrecision] / N[(N[(4.0 * N[(beta * i), $MachinePrecision] + N[(4.0 * N[(i * i), $MachinePrecision] + N[(beta * beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[beta, 4.3e+170], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \left(\beta + \alpha\right) + i \cdot 2\\
t_1 := -1 + t_0 \cdot t_0\\
t_2 := {\left(\beta + i\right)}^{2}\\
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{\frac{t_2 \cdot {i}^{2}}{{\left(\beta + i \cdot 2\right)}^{2}}}{t_1}\\
\mathbf{elif}\;\beta \leq 4 \cdot 10^{+99}:\\
\;\;\;\;0.0625\\
\mathbf{elif}\;\beta \leq 5.3 \cdot 10^{+141}:\\
\;\;\;\;\frac{\frac{i \cdot i}{\frac{\mathsf{fma}\left(4, \beta \cdot i, \mathsf{fma}\left(4, i \cdot i, \beta \cdot \beta\right)\right)}{t_2}}}{t_1}\\
\mathbf{elif}\;\beta \leq 4.3 \cdot 10^{+170}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
Taylor expanded in alpha around 0 99.4%
if 3.2999999999999999e69 < beta < 3.9999999999999999e99Initial program 0.8%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.8%
Simplified27.0%
Taylor expanded in i around inf 74.4%
if 3.9999999999999999e99 < beta < 5.3e141Initial program 15.9%
Taylor expanded in alpha around 0 15.9%
associate-/l*84.9%
unpow284.9%
+-commutative84.9%
*-commutative84.9%
fma-udef84.9%
Simplified84.9%
Taylor expanded in i around 0 85.3%
fma-def85.3%
fma-def85.3%
unpow285.3%
unpow285.3%
Simplified85.3%
if 5.3e141 < beta < 4.2999999999999999e170Initial program 0.1%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.1%
Simplified8.8%
Taylor expanded in i around inf 84.4%
Taylor expanded in alpha around 0 76.2%
if 4.2999999999999999e170 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification77.0%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (+ beta (* i 2.0))))
(t_1 (+ (+ beta alpha) (* i 2.0)))
(t_2 (pow (+ beta i) 2.0)))
(if (<= beta 4.1e+63)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(/ (* (* i i) t_2) (* (fma t_0 t_0 -1.0) (* t_0 t_0)))
(if (<= beta 1.25e+99)
0.0625
(if (<= beta 1.4e+141)
(/
(/ (* i i) (/ (pow (fma i 2.0 beta) 2.0) t_2))
(+ -1.0 (* t_1 t_1)))
(if (<= beta 4.9e+170)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = alpha + (beta + (i * 2.0));
double t_1 = (beta + alpha) + (i * 2.0);
double t_2 = pow((beta + i), 2.0);
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = ((i * i) * t_2) / (fma(t_0, t_0, -1.0) * (t_0 * t_0));
} else if (beta <= 1.25e+99) {
tmp = 0.0625;
} else if (beta <= 1.4e+141) {
tmp = ((i * i) / (pow(fma(i, 2.0, beta), 2.0) / t_2)) / (-1.0 + (t_1 * t_1));
} else if (beta <= 4.9e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(alpha + Float64(beta + Float64(i * 2.0))) t_1 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) t_2 = Float64(beta + i) ^ 2.0 tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(i * i) * t_2) / Float64(fma(t_0, t_0, -1.0) * Float64(t_0 * t_0))); elseif (beta <= 1.25e+99) tmp = 0.0625; elseif (beta <= 1.4e+141) tmp = Float64(Float64(Float64(i * i) / Float64((fma(i, 2.0, beta) ^ 2.0) / t_2)) / Float64(-1.0 + Float64(t_1 * t_1))); elseif (beta <= 4.9e+170) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(beta + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(beta + i), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(i * i), $MachinePrecision] * t$95$2), $MachinePrecision] / N[(N[(t$95$0 * t$95$0 + -1.0), $MachinePrecision] * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 1.25e+99], 0.0625, If[LessEqual[beta, 1.4e+141], N[(N[(N[(i * i), $MachinePrecision] / N[(N[Power[N[(i * 2.0 + beta), $MachinePrecision], 2.0], $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision] / N[(-1.0 + N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 4.9e+170], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \alpha + \left(\beta + i \cdot 2\right)\\
t_1 := \left(\beta + \alpha\right) + i \cdot 2\\
t_2 := {\left(\beta + i\right)}^{2}\\
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{\left(i \cdot i\right) \cdot t_2}{\mathsf{fma}\left(t_0, t_0, -1\right) \cdot \left(t_0 \cdot t_0\right)}\\
\mathbf{elif}\;\beta \leq 1.25 \cdot 10^{+99}:\\
\;\;\;\;0.0625\\
\mathbf{elif}\;\beta \leq 1.4 \cdot 10^{+141}:\\
\;\;\;\;\frac{\frac{i \cdot i}{\frac{{\left(\mathsf{fma}\left(i, 2, \beta\right)\right)}^{2}}{t_2}}}{-1 + t_1 \cdot t_1}\\
\mathbf{elif}\;\beta \leq 4.9 \cdot 10^{+170}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
Simplified74.1%
Taylor expanded in alpha around 0 99.2%
unpow299.2%
Simplified99.2%
if 3.2999999999999999e69 < beta < 1.25000000000000002e99Initial program 0.8%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.8%
Simplified27.0%
Taylor expanded in i around inf 74.4%
if 1.25000000000000002e99 < beta < 1.39999999999999996e141Initial program 15.9%
Taylor expanded in alpha around 0 15.9%
associate-/l*84.9%
unpow284.9%
+-commutative84.9%
*-commutative84.9%
fma-udef84.9%
Simplified84.9%
if 1.39999999999999996e141 < beta < 4.9000000000000004e170Initial program 0.1%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.1%
Simplified8.8%
Taylor expanded in i around inf 84.4%
Taylor expanded in alpha around 0 76.2%
if 4.9000000000000004e170 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification77.0%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ beta alpha) (* i 2.0)))
(t_1 (+ -1.0 (* t_0 t_0)))
(t_2 (pow (+ beta i) 2.0)))
(if (<= beta 4.1e+63)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(/ (/ (* t_2 (pow i 2.0)) (pow (+ beta (* i 2.0)) 2.0)) t_1)
(if (<= beta 4.3e+99)
0.0625
(if (<= beta 1.55e+142)
(/ (/ (* i i) (/ (pow (fma i 2.0 beta) 2.0) t_2)) t_1)
(if (<= beta 4.9e+170)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = (beta + alpha) + (i * 2.0);
double t_1 = -1.0 + (t_0 * t_0);
double t_2 = pow((beta + i), 2.0);
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = ((t_2 * pow(i, 2.0)) / pow((beta + (i * 2.0)), 2.0)) / t_1;
} else if (beta <= 4.3e+99) {
tmp = 0.0625;
} else if (beta <= 1.55e+142) {
tmp = ((i * i) / (pow(fma(i, 2.0, beta), 2.0) / t_2)) / t_1;
} else if (beta <= 4.9e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) t_1 = Float64(-1.0 + Float64(t_0 * t_0)) t_2 = Float64(beta + i) ^ 2.0 tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(t_2 * (i ^ 2.0)) / (Float64(beta + Float64(i * 2.0)) ^ 2.0)) / t_1); elseif (beta <= 4.3e+99) tmp = 0.0625; elseif (beta <= 1.55e+142) tmp = Float64(Float64(Float64(i * i) / Float64((fma(i, 2.0, beta) ^ 2.0) / t_2)) / t_1); elseif (beta <= 4.9e+170) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(-1.0 + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(beta + i), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(t$95$2 * N[Power[i, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[N[(beta + N[(i * 2.0), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[beta, 4.3e+99], 0.0625, If[LessEqual[beta, 1.55e+142], N[(N[(N[(i * i), $MachinePrecision] / N[(N[Power[N[(i * 2.0 + beta), $MachinePrecision], 2.0], $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[beta, 4.9e+170], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \left(\beta + \alpha\right) + i \cdot 2\\
t_1 := -1 + t_0 \cdot t_0\\
t_2 := {\left(\beta + i\right)}^{2}\\
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{\frac{t_2 \cdot {i}^{2}}{{\left(\beta + i \cdot 2\right)}^{2}}}{t_1}\\
\mathbf{elif}\;\beta \leq 4.3 \cdot 10^{+99}:\\
\;\;\;\;0.0625\\
\mathbf{elif}\;\beta \leq 1.55 \cdot 10^{+142}:\\
\;\;\;\;\frac{\frac{i \cdot i}{\frac{{\left(\mathsf{fma}\left(i, 2, \beta\right)\right)}^{2}}{t_2}}}{t_1}\\
\mathbf{elif}\;\beta \leq 4.9 \cdot 10^{+170}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
Taylor expanded in alpha around 0 99.4%
if 3.2999999999999999e69 < beta < 4.3000000000000001e99Initial program 0.8%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.8%
Simplified27.0%
Taylor expanded in i around inf 74.4%
if 4.3000000000000001e99 < beta < 1.55e142Initial program 15.9%
Taylor expanded in alpha around 0 15.9%
associate-/l*84.9%
unpow284.9%
+-commutative84.9%
*-commutative84.9%
fma-udef84.9%
Simplified84.9%
if 1.55e142 < beta < 4.9000000000000004e170Initial program 0.1%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.1%
Simplified8.8%
Taylor expanded in i around inf 84.4%
Taylor expanded in alpha around 0 76.2%
if 4.9000000000000004e170 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification77.0%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (+ beta (* i 2.0)))))
(if (<= beta 4.1e+63)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(/ (* (* i i) (pow (+ beta i) 2.0)) (* (fma t_0 t_0 -1.0) (* t_0 t_0)))
(if (<= beta 3.5e+171)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = alpha + (beta + (i * 2.0));
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = ((i * i) * pow((beta + i), 2.0)) / (fma(t_0, t_0, -1.0) * (t_0 * t_0));
} else if (beta <= 3.5e+171) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(alpha + Float64(beta + Float64(i * 2.0))) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(i * i) * (Float64(beta + i) ^ 2.0)) / Float64(fma(t_0, t_0, -1.0) * Float64(t_0 * t_0))); elseif (beta <= 3.5e+171) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(beta + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(i * i), $MachinePrecision] * N[Power[N[(beta + i), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$0 * t$95$0 + -1.0), $MachinePrecision] * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.5e+171], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \alpha + \left(\beta + i \cdot 2\right)\\
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{\left(i \cdot i\right) \cdot {\left(\beta + i\right)}^{2}}{\mathsf{fma}\left(t_0, t_0, -1\right) \cdot \left(t_0 \cdot t_0\right)}\\
\mathbf{elif}\;\beta \leq 3.5 \cdot 10^{+171}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
Simplified74.1%
Taylor expanded in alpha around 0 99.2%
unpow299.2%
Simplified99.2%
if 3.2999999999999999e69 < beta < 3.4999999999999999e171Initial program 4.1%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.8%
Simplified33.1%
Taylor expanded in i around inf 71.0%
Taylor expanded in alpha around 0 64.1%
if 3.4999999999999999e171 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification75.4%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ alpha (+ beta (* i 2.0)))) (t_1 (* i (+ i (+ beta alpha)))))
(if (<= beta 2.85e+63)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(/ (* t_1 (+ t_1 (* beta alpha))) (* (fma t_0 t_0 -1.0) (* t_0 t_0)))
(if (<= beta 8.4e+170)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = alpha + (beta + (i * 2.0));
double t_1 = i * (i + (beta + alpha));
double tmp;
if (beta <= 2.85e+63) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = (t_1 * (t_1 + (beta * alpha))) / (fma(t_0, t_0, -1.0) * (t_0 * t_0));
} else if (beta <= 8.4e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(alpha + Float64(beta + Float64(i * 2.0))) t_1 = Float64(i * Float64(i + Float64(beta + alpha))) tmp = 0.0 if (beta <= 2.85e+63) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(t_1 * Float64(t_1 + Float64(beta * alpha))) / Float64(fma(t_0, t_0, -1.0) * Float64(t_0 * t_0))); elseif (beta <= 8.4e+170) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(alpha + N[(beta + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(i * N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 2.85e+63], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(t$95$1 * N[(t$95$1 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(t$95$0 * t$95$0 + -1.0), $MachinePrecision] * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 8.4e+170], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \alpha + \left(\beta + i \cdot 2\right)\\
t_1 := i \cdot \left(i + \left(\beta + \alpha\right)\right)\\
\mathbf{if}\;\beta \leq 2.85 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{t_1 \cdot \left(t_1 + \beta \cdot \alpha\right)}{\mathsf{fma}\left(t_0, t_0, -1\right) \cdot \left(t_0 \cdot t_0\right)}\\
\mathbf{elif}\;\beta \leq 8.4 \cdot 10^{+170}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 2.8500000000000001e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
if 2.8500000000000001e63 < beta < 3.2999999999999999e69Initial program 74.1%
Simplified74.1%
associate-*l*74.1%
+-commutative74.1%
fma-udef74.1%
*-commutative74.1%
+-commutative74.1%
associate-*l*74.1%
distribute-rgt-in74.1%
*-commutative74.1%
+-commutative74.1%
+-commutative74.1%
+-commutative74.1%
Applied egg-rr74.1%
distribute-rgt-out74.1%
+-commutative74.1%
+-commutative74.1%
Simplified74.1%
if 3.2999999999999999e69 < beta < 8.39999999999999991e170Initial program 4.1%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.8%
Simplified33.1%
Taylor expanded in i around inf 71.0%
Taylor expanded in alpha around 0 64.1%
if 8.39999999999999991e170 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification75.0%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ beta alpha) (* i 2.0)))
(t_1 (* t_0 t_0))
(t_2 (* i (+ i (+ beta alpha)))))
(if (<= beta 4e+63)
(+
0.0625
(-
(/ (* 0.0625 (* beta beta)) (* i i))
(/
(* 0.00390625 (fma 4.0 (+ (* beta beta) -1.0) (* (* beta beta) 20.0)))
(* i i))))
(if (<= beta 3.3e+69)
(/ (/ (* t_2 (+ t_2 (* beta alpha))) t_1) (+ -1.0 t_1))
(if (<= beta 7.4e+171)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = (beta + alpha) + (i * 2.0);
double t_1 = t_0 * t_0;
double t_2 = i * (i + (beta + alpha));
double tmp;
if (beta <= 4e+63) {
tmp = 0.0625 + (((0.0625 * (beta * beta)) / (i * i)) - ((0.00390625 * fma(4.0, ((beta * beta) + -1.0), ((beta * beta) * 20.0))) / (i * i)));
} else if (beta <= 3.3e+69) {
tmp = ((t_2 * (t_2 + (beta * alpha))) / t_1) / (-1.0 + t_1);
} else if (beta <= 7.4e+171) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) t_1 = Float64(t_0 * t_0) t_2 = Float64(i * Float64(i + Float64(beta + alpha))) tmp = 0.0 if (beta <= 4e+63) tmp = Float64(0.0625 + Float64(Float64(Float64(0.0625 * Float64(beta * beta)) / Float64(i * i)) - Float64(Float64(0.00390625 * fma(4.0, Float64(Float64(beta * beta) + -1.0), Float64(Float64(beta * beta) * 20.0))) / Float64(i * i)))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(t_2 * Float64(t_2 + Float64(beta * alpha))) / t_1) / Float64(-1.0 + t_1)); elseif (beta <= 7.4e+171) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 4e+63], N[(0.0625 + N[(N[(N[(0.0625 * N[(beta * beta), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision] - N[(N[(0.00390625 * N[(4.0 * N[(N[(beta * beta), $MachinePrecision] + -1.0), $MachinePrecision] + N[(N[(beta * beta), $MachinePrecision] * 20.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(t$95$2 * N[(t$95$2 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] / N[(-1.0 + t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 7.4e+171], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \left(\beta + \alpha\right) + i \cdot 2\\
t_1 := t_0 \cdot t_0\\
t_2 := i \cdot \left(i + \left(\beta + \alpha\right)\right)\\
\mathbf{if}\;\beta \leq 4 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \left(\frac{0.0625 \cdot \left(\beta \cdot \beta\right)}{i \cdot i} - \frac{0.00390625 \cdot \mathsf{fma}\left(4, \beta \cdot \beta + -1, \left(\beta \cdot \beta\right) \cdot 20\right)}{i \cdot i}\right)\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{\frac{t_2 \cdot \left(t_2 + \beta \cdot \alpha\right)}{t_1}}{-1 + t_1}\\
\mathbf{elif}\;\beta \leq 7.4 \cdot 10^{+171}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.00000000000000023e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
if 4.00000000000000023e63 < beta < 3.2999999999999999e69Initial program 74.1%
if 3.2999999999999999e69 < beta < 7.39999999999999996e171Initial program 4.1%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.8%
Simplified33.1%
Taylor expanded in i around inf 71.0%
Taylor expanded in alpha around 0 64.1%
if 7.39999999999999996e171 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification75.0%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (* i (+ i (+ beta alpha))))
(t_1 (+ (+ beta alpha) (* i 2.0)))
(t_2 (* t_1 t_1)))
(if (<= beta 4.1e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ (/ (* t_0 (+ t_0 (* beta alpha))) t_2) (+ -1.0 t_2))
(if (<= beta 4.7e+170)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = i * (i + (beta + alpha));
double t_1 = (beta + alpha) + (i * 2.0);
double t_2 = t_1 * t_1;
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = ((t_0 * (t_0 + (beta * alpha))) / t_2) / (-1.0 + t_2);
} else if (beta <= 4.7e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = i * (i + (beta + alpha))
t_1 = (beta + alpha) + (i * 2.0d0)
t_2 = t_1 * t_1
if (beta <= 4.1d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = ((t_0 * (t_0 + (beta * alpha))) / t_2) / ((-1.0d0) + t_2)
else if (beta <= 4.7d+170) then
tmp = (0.0625d0 + (0.0625d0 * (2.0d0 * (beta / i)))) - (0.125d0 * ((beta + alpha) / i))
else
tmp = (i / beta) * ((i + alpha) / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double t_0 = i * (i + (beta + alpha));
double t_1 = (beta + alpha) + (i * 2.0);
double t_2 = t_1 * t_1;
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = ((t_0 * (t_0 + (beta * alpha))) / t_2) / (-1.0 + t_2);
} else if (beta <= 4.7e+170) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): t_0 = i * (i + (beta + alpha)) t_1 = (beta + alpha) + (i * 2.0) t_2 = t_1 * t_1 tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = ((t_0 * (t_0 + (beta * alpha))) / t_2) / (-1.0 + t_2) elif beta <= 4.7e+170: tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i)) else: tmp = (i / beta) * ((i + alpha) / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(i * Float64(i + Float64(beta + alpha))) t_1 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) t_2 = Float64(t_1 * t_1) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(t_0 * Float64(t_0 + Float64(beta * alpha))) / t_2) / Float64(-1.0 + t_2)); elseif (beta <= 4.7e+170) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
t_0 = i * (i + (beta + alpha));
t_1 = (beta + alpha) + (i * 2.0);
t_2 = t_1 * t_1;
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = ((t_0 * (t_0 + (beta * alpha))) / t_2) / (-1.0 + t_2);
elseif (beta <= 4.7e+170)
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
else
tmp = (i / beta) * ((i + alpha) / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(i * N[(i + N[(beta + alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * t$95$1), $MachinePrecision]}, If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(t$95$0 * N[(t$95$0 + N[(beta * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] / N[(-1.0 + t$95$2), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 4.7e+170], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := i \cdot \left(i + \left(\beta + \alpha\right)\right)\\
t_1 := \left(\beta + \alpha\right) + i \cdot 2\\
t_2 := t_1 \cdot t_1\\
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{\frac{t_0 \cdot \left(t_0 + \beta \cdot \alpha\right)}{t_2}}{-1 + t_2}\\
\mathbf{elif}\;\beta \leq 4.7 \cdot 10^{+170}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
if 3.2999999999999999e69 < beta < 4.70000000000000004e170Initial program 4.1%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.8%
Simplified33.1%
Taylor expanded in i around inf 71.0%
Taylor expanded in alpha around 0 64.1%
if 4.70000000000000004e170 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification75.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ beta alpha) (* i 2.0))))
(if (<= beta 4.1e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ (/ (* i i) (- 1.0 (/ (* i -2.0) beta))) (+ -1.0 (* t_0 t_0)))
(if (<= beta 3.6e+171)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = (beta + alpha) + (i * 2.0);
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = ((i * i) / (1.0 - ((i * -2.0) / beta))) / (-1.0 + (t_0 * t_0));
} else if (beta <= 3.6e+171) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: tmp
t_0 = (beta + alpha) + (i * 2.0d0)
if (beta <= 4.1d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = ((i * i) / (1.0d0 - ((i * (-2.0d0)) / beta))) / ((-1.0d0) + (t_0 * t_0))
else if (beta <= 3.6d+171) then
tmp = (0.0625d0 + (0.0625d0 * (2.0d0 * (beta / i)))) - (0.125d0 * ((beta + alpha) / i))
else
tmp = (i / beta) * ((i + alpha) / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double t_0 = (beta + alpha) + (i * 2.0);
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = ((i * i) / (1.0 - ((i * -2.0) / beta))) / (-1.0 + (t_0 * t_0));
} else if (beta <= 3.6e+171) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): t_0 = (beta + alpha) + (i * 2.0) tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = ((i * i) / (1.0 - ((i * -2.0) / beta))) / (-1.0 + (t_0 * t_0)) elif beta <= 3.6e+171: tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i)) else: tmp = (i / beta) * ((i + alpha) / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(Float64(i * i) / Float64(1.0 - Float64(Float64(i * -2.0) / beta))) / Float64(-1.0 + Float64(t_0 * t_0))); elseif (beta <= 3.6e+171) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
t_0 = (beta + alpha) + (i * 2.0);
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = ((i * i) / (1.0 - ((i * -2.0) / beta))) / (-1.0 + (t_0 * t_0));
elseif (beta <= 3.6e+171)
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
else
tmp = (i / beta) * ((i + alpha) / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(N[(i * i), $MachinePrecision] / N[(1.0 - N[(N[(i * -2.0), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(-1.0 + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.6e+171], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \left(\beta + \alpha\right) + i \cdot 2\\
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{\frac{i \cdot i}{1 - \frac{i \cdot -2}{\beta}}}{-1 + t_0 \cdot t_0}\\
\mathbf{elif}\;\beta \leq 3.6 \cdot 10^{+171}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
Taylor expanded in alpha around 0 99.4%
associate-/l*99.1%
unpow299.1%
+-commutative99.1%
*-commutative99.1%
fma-udef99.1%
Simplified99.1%
Taylor expanded in beta around -inf 78.4%
mul-1-neg78.4%
unsub-neg78.4%
distribute-rgt-out--78.4%
metadata-eval78.4%
Simplified78.4%
if 3.2999999999999999e69 < beta < 3.60000000000000018e171Initial program 4.1%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.8%
Simplified33.1%
Taylor expanded in i around inf 71.0%
Taylor expanded in alpha around 0 64.1%
if 3.60000000000000018e171 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification75.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(let* ((t_0 (+ (+ beta alpha) (* i 2.0))))
(if (<= beta 4.1e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ (* i i) (+ -1.0 (* t_0 t_0)))
(if (<= beta 6.4e+171)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta)))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double t_0 = (beta + alpha) + (i * 2.0);
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (-1.0 + (t_0 * t_0));
} else if (beta <= 6.4e+171) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: t_0
real(8) :: tmp
t_0 = (beta + alpha) + (i * 2.0d0)
if (beta <= 4.1d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = (i * i) / ((-1.0d0) + (t_0 * t_0))
else if (beta <= 6.4d+171) then
tmp = (0.0625d0 + (0.0625d0 * (2.0d0 * (beta / i)))) - (0.125d0 * ((beta + alpha) / i))
else
tmp = (i / beta) * ((i + alpha) / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double t_0 = (beta + alpha) + (i * 2.0);
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (-1.0 + (t_0 * t_0));
} else if (beta <= 6.4e+171) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): t_0 = (beta + alpha) + (i * 2.0) tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = (i * i) / (-1.0 + (t_0 * t_0)) elif beta <= 6.4e+171: tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i)) else: tmp = (i / beta) * ((i + alpha) / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) t_0 = Float64(Float64(beta + alpha) + Float64(i * 2.0)) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(i * i) / Float64(-1.0 + Float64(t_0 * t_0))); elseif (beta <= 6.4e+171) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
t_0 = (beta + alpha) + (i * 2.0);
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = (i * i) / (-1.0 + (t_0 * t_0));
elseif (beta <= 6.4e+171)
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
else
tmp = (i / beta) * ((i + alpha) / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function.
code[alpha_, beta_, i_] := Block[{t$95$0 = N[(N[(beta + alpha), $MachinePrecision] + N[(i * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(i * i), $MachinePrecision] / N[(-1.0 + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 6.4e+171], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
t_0 := \left(\beta + \alpha\right) + i \cdot 2\\
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i \cdot i}{-1 + t_0 \cdot t_0}\\
\mathbf{elif}\;\beta \leq 6.4 \cdot 10^{+171}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
Taylor expanded in alpha around 0 99.4%
associate-/l*99.1%
unpow299.1%
+-commutative99.1%
*-commutative99.1%
fma-udef99.1%
Simplified99.1%
Taylor expanded in beta around inf 75.4%
associate--l+75.4%
distribute-lft-out75.4%
unpow275.4%
unpow275.4%
fma-def75.4%
+-commutative75.4%
unpow275.4%
unpow275.4%
Simplified75.4%
Taylor expanded in i around 0 79.3%
unpow279.3%
Simplified79.3%
if 3.2999999999999999e69 < beta < 6.40000000000000022e171Initial program 4.1%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.8%
Simplified33.1%
Taylor expanded in i around inf 71.0%
Taylor expanded in alpha around 0 64.1%
if 6.40000000000000022e171 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification75.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(if (<= beta 3.7e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ (* i i) (* beta beta))
(if (<= beta 2e+172)
(-
(+ 0.0625 (* 0.0625 (* 2.0 (/ beta i))))
(* 0.125 (/ (+ beta alpha) i)))
(* (/ i beta) (/ (+ i alpha) beta))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 3.7e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2e+172) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 3.7d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = (i * i) / (beta * beta)
else if (beta <= 2d+172) then
tmp = (0.0625d0 + (0.0625d0 * (2.0d0 * (beta / i)))) - (0.125d0 * ((beta + alpha) / i))
else
tmp = (i / beta) * ((i + alpha) / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 3.7e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2e+172) {
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 3.7e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = (i * i) / (beta * beta) elif beta <= 2e+172: tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i)) else: tmp = (i / beta) * ((i + alpha) / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 3.7e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(i * i) / Float64(beta * beta)); elseif (beta <= 2e+172) tmp = Float64(Float64(0.0625 + Float64(0.0625 * Float64(2.0 * Float64(beta / i)))) - Float64(0.125 * Float64(Float64(beta + alpha) / i))); else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 3.7e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = (i * i) / (beta * beta);
elseif (beta <= 2e+172)
tmp = (0.0625 + (0.0625 * (2.0 * (beta / i)))) - (0.125 * ((beta + alpha) / i));
else
tmp = (i / beta) * ((i + alpha) / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 3.7e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(i * i), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 2e+172], N[(N[(0.0625 + N[(0.0625 * N[(2.0 * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(0.125 * N[(N[(beta + alpha), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 3.7 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i \cdot i}{\beta \cdot \beta}\\
\mathbf{elif}\;\beta \leq 2 \cdot 10^{+172}:\\
\;\;\;\;\left(0.0625 + 0.0625 \cdot \left(2 \cdot \frac{\beta}{i}\right)\right) - 0.125 \cdot \frac{\beta + \alpha}{i}\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 3.69999999999999968e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 3.69999999999999968e63 < beta < 3.2999999999999999e69Initial program 74.1%
associate-/l/74.1%
associate-*l*74.1%
times-frac73.7%
Simplified73.7%
Taylor expanded in beta around inf 53.2%
associate-/l*52.9%
unpow252.9%
Simplified52.9%
Taylor expanded in i around inf 53.7%
unpow253.7%
unpow253.7%
Simplified53.7%
if 3.2999999999999999e69 < beta < 2.0000000000000002e172Initial program 4.1%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.8%
Simplified33.1%
Taylor expanded in i around inf 71.0%
Taylor expanded in alpha around 0 64.1%
if 2.0000000000000002e172 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified7.9%
Taylor expanded in beta around inf 13.6%
associate-/l*16.3%
unpow216.3%
Simplified16.3%
div-inv16.3%
Applied egg-rr16.3%
Taylor expanded in beta around 0 13.6%
+-commutative13.6%
unpow213.6%
times-frac74.6%
+-commutative74.6%
Simplified74.6%
Final simplification74.7%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(if (<= beta 4.1e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ (* i i) (* beta beta))
(if (<= beta 2.3e+173) 0.0625 (* (/ i beta) (/ (+ i alpha) beta))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2.3e+173) {
tmp = 0.0625;
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 4.1d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = (i * i) / (beta * beta)
else if (beta <= 2.3d+173) then
tmp = 0.0625d0
else
tmp = (i / beta) * ((i + alpha) / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2.3e+173) {
tmp = 0.0625;
} else {
tmp = (i / beta) * ((i + alpha) / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = (i * i) / (beta * beta) elif beta <= 2.3e+173: tmp = 0.0625 else: tmp = (i / beta) * ((i + alpha) / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(i * i) / Float64(beta * beta)); elseif (beta <= 2.3e+173) tmp = 0.0625; else tmp = Float64(Float64(i / beta) * Float64(Float64(i + alpha) / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = (i * i) / (beta * beta);
elseif (beta <= 2.3e+173)
tmp = 0.0625;
else
tmp = (i / beta) * ((i + alpha) / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(i * i), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 2.3e+173], 0.0625, N[(N[(i / beta), $MachinePrecision] * N[(N[(i + alpha), $MachinePrecision] / beta), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i \cdot i}{\beta \cdot \beta}\\
\mathbf{elif}\;\beta \leq 2.3 \cdot 10^{+173}:\\
\;\;\;\;0.0625\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i + \alpha}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
associate-/l/74.1%
associate-*l*74.1%
times-frac73.7%
Simplified73.7%
Taylor expanded in beta around inf 53.2%
associate-/l*52.9%
unpow252.9%
Simplified52.9%
Taylor expanded in i around inf 53.7%
unpow253.7%
unpow253.7%
Simplified53.7%
if 3.2999999999999999e69 < beta < 2.29999999999999995e173Initial program 4.0%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.4%
Simplified32.1%
Taylor expanded in i around inf 65.6%
if 2.29999999999999995e173 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified8.1%
Taylor expanded in beta around inf 14.0%
associate-/l*16.7%
unpow216.7%
Simplified16.7%
div-inv16.7%
Applied egg-rr16.7%
Taylor expanded in beta around 0 14.0%
+-commutative14.0%
unpow214.0%
times-frac76.4%
+-commutative76.4%
Simplified76.4%
Final simplification75.2%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(if (<= beta 1.3e+61)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ (* i i) (* beta beta))
(if (<= beta 2.4e+173) 0.0625 (/ (* (/ i beta) (+ i alpha)) beta)))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 1.3e+61) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2.4e+173) {
tmp = 0.0625;
} else {
tmp = ((i / beta) * (i + alpha)) / beta;
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 1.3d+61) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = (i * i) / (beta * beta)
else if (beta <= 2.4d+173) then
tmp = 0.0625d0
else
tmp = ((i / beta) * (i + alpha)) / beta
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 1.3e+61) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2.4e+173) {
tmp = 0.0625;
} else {
tmp = ((i / beta) * (i + alpha)) / beta;
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 1.3e+61: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = (i * i) / (beta * beta) elif beta <= 2.4e+173: tmp = 0.0625 else: tmp = ((i / beta) * (i + alpha)) / beta return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 1.3e+61) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(i * i) / Float64(beta * beta)); elseif (beta <= 2.4e+173) tmp = 0.0625; else tmp = Float64(Float64(Float64(i / beta) * Float64(i + alpha)) / beta); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 1.3e+61)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = (i * i) / (beta * beta);
elseif (beta <= 2.4e+173)
tmp = 0.0625;
else
tmp = ((i / beta) * (i + alpha)) / beta;
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 1.3e+61], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(i * i), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 2.4e+173], 0.0625, N[(N[(N[(i / beta), $MachinePrecision] * N[(i + alpha), $MachinePrecision]), $MachinePrecision] / beta), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 1.3 \cdot 10^{+61}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i \cdot i}{\beta \cdot \beta}\\
\mathbf{elif}\;\beta \leq 2.4 \cdot 10^{+173}:\\
\;\;\;\;0.0625\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{i}{\beta} \cdot \left(i + \alpha\right)}{\beta}\\
\end{array}
\end{array}
if beta < 1.29999999999999986e61Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 1.29999999999999986e61 < beta < 3.2999999999999999e69Initial program 74.1%
associate-/l/74.1%
associate-*l*74.1%
times-frac73.7%
Simplified73.7%
Taylor expanded in beta around inf 53.2%
associate-/l*52.9%
unpow252.9%
Simplified52.9%
Taylor expanded in i around inf 53.7%
unpow253.7%
unpow253.7%
Simplified53.7%
if 3.2999999999999999e69 < beta < 2.3999999999999999e173Initial program 4.0%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.4%
Simplified32.1%
Taylor expanded in i around inf 65.6%
if 2.3999999999999999e173 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified8.1%
Taylor expanded in beta around inf 14.0%
associate-/l*16.7%
unpow216.7%
Simplified16.7%
div-inv16.7%
Applied egg-rr16.7%
Taylor expanded in beta around 0 14.0%
+-commutative14.0%
unpow214.0%
times-frac76.4%
+-commutative76.4%
Simplified76.4%
associate-*r/76.3%
+-commutative76.3%
Applied egg-rr76.3%
Final simplification75.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(if (<= beta 4.1e+63)
0.0625
(if (or (<= beta 3.3e+69) (not (<= beta 2e+173)))
(* (/ i beta) (/ i beta))
0.0625)))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625;
} else if ((beta <= 3.3e+69) || !(beta <= 2e+173)) {
tmp = (i / beta) * (i / beta);
} else {
tmp = 0.0625;
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 4.1d+63) then
tmp = 0.0625d0
else if ((beta <= 3.3d+69) .or. (.not. (beta <= 2d+173))) then
tmp = (i / beta) * (i / beta)
else
tmp = 0.0625d0
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625;
} else if ((beta <= 3.3e+69) || !(beta <= 2e+173)) {
tmp = (i / beta) * (i / beta);
} else {
tmp = 0.0625;
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 elif (beta <= 3.3e+69) or not (beta <= 2e+173): tmp = (i / beta) * (i / beta) else: tmp = 0.0625 return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 4.1e+63) tmp = 0.0625; elseif ((beta <= 3.3e+69) || !(beta <= 2e+173)) tmp = Float64(Float64(i / beta) * Float64(i / beta)); else tmp = 0.0625; end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625;
elseif ((beta <= 3.3e+69) || ~((beta <= 2e+173)))
tmp = (i / beta) * (i / beta);
else
tmp = 0.0625;
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 4.1e+63], 0.0625, If[Or[LessEqual[beta, 3.3e+69], N[Not[LessEqual[beta, 2e+173]], $MachinePrecision]], N[(N[(i / beta), $MachinePrecision] * N[(i / beta), $MachinePrecision]), $MachinePrecision], 0.0625]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69} \lor \neg \left(\beta \leq 2 \cdot 10^{+173}\right):\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i}{\beta}\\
\mathbf{else}:\\
\;\;\;\;0.0625\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63 or 3.2999999999999999e69 < beta < 2e173Initial program 19.1%
associate-/l/17.5%
associate-*l*17.3%
times-frac24.6%
Simplified47.5%
Taylor expanded in i around inf 75.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69 or 2e173 < beta Initial program 6.7%
associate-/l/6.7%
associate-*l*6.7%
times-frac6.7%
Simplified14.1%
Taylor expanded in beta around inf 17.5%
associate-/l*20.0%
unpow220.0%
Simplified20.0%
div-inv20.0%
Applied egg-rr20.0%
Taylor expanded in i around inf 17.7%
unpow217.7%
unpow217.7%
times-frac68.0%
Simplified68.0%
Final simplification73.8%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(if (<= beta 4.1e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (or (<= beta 3.3e+69) (not (<= beta 3.5e+173)))
(* (/ i beta) (/ i beta))
0.0625)))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if ((beta <= 3.3e+69) || !(beta <= 3.5e+173)) {
tmp = (i / beta) * (i / beta);
} else {
tmp = 0.0625;
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 4.1d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if ((beta <= 3.3d+69) .or. (.not. (beta <= 3.5d+173))) then
tmp = (i / beta) * (i / beta)
else
tmp = 0.0625d0
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if ((beta <= 3.3e+69) || !(beta <= 3.5e+173)) {
tmp = (i / beta) * (i / beta);
} else {
tmp = 0.0625;
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif (beta <= 3.3e+69) or not (beta <= 3.5e+173): tmp = (i / beta) * (i / beta) else: tmp = 0.0625 return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif ((beta <= 3.3e+69) || !(beta <= 3.5e+173)) tmp = Float64(Float64(i / beta) * Float64(i / beta)); else tmp = 0.0625; end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif ((beta <= 3.3e+69) || ~((beta <= 3.5e+173)))
tmp = (i / beta) * (i / beta);
else
tmp = 0.0625;
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[beta, 3.3e+69], N[Not[LessEqual[beta, 3.5e+173]], $MachinePrecision]], N[(N[(i / beta), $MachinePrecision] * N[(i / beta), $MachinePrecision]), $MachinePrecision], 0.0625]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69} \lor \neg \left(\beta \leq 3.5 \cdot 10^{+173}\right):\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i}{\beta}\\
\mathbf{else}:\\
\;\;\;\;0.0625\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69 or 3.4999999999999999e173 < beta Initial program 6.7%
associate-/l/6.7%
associate-*l*6.7%
times-frac6.7%
Simplified14.1%
Taylor expanded in beta around inf 17.5%
associate-/l*20.0%
unpow220.0%
Simplified20.0%
div-inv20.0%
Applied egg-rr20.0%
Taylor expanded in i around inf 17.7%
unpow217.7%
unpow217.7%
times-frac68.0%
Simplified68.0%
if 3.2999999999999999e69 < beta < 3.4999999999999999e173Initial program 4.0%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.4%
Simplified32.1%
Taylor expanded in i around inf 65.6%
Final simplification74.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(if (<= beta 4.1e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ i (* beta (/ beta i)))
(if (<= beta 2.36e+173) 0.0625 (* (/ i beta) (/ i beta))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = i / (beta * (beta / i));
} else if (beta <= 2.36e+173) {
tmp = 0.0625;
} else {
tmp = (i / beta) * (i / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 4.1d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = i / (beta * (beta / i))
else if (beta <= 2.36d+173) then
tmp = 0.0625d0
else
tmp = (i / beta) * (i / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = i / (beta * (beta / i));
} else if (beta <= 2.36e+173) {
tmp = 0.0625;
} else {
tmp = (i / beta) * (i / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = i / (beta * (beta / i)) elif beta <= 2.36e+173: tmp = 0.0625 else: tmp = (i / beta) * (i / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(i / Float64(beta * Float64(beta / i))); elseif (beta <= 2.36e+173) tmp = 0.0625; else tmp = Float64(Float64(i / beta) * Float64(i / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = i / (beta * (beta / i));
elseif (beta <= 2.36e+173)
tmp = 0.0625;
else
tmp = (i / beta) * (i / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(i / N[(beta * N[(beta / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 2.36e+173], 0.0625, N[(N[(i / beta), $MachinePrecision] * N[(i / beta), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i}{\beta \cdot \frac{\beta}{i}}\\
\mathbf{elif}\;\beta \leq 2.36 \cdot 10^{+173}:\\
\;\;\;\;0.0625\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
associate-/l/74.1%
associate-*l*74.1%
times-frac73.7%
Simplified73.7%
Taylor expanded in beta around inf 53.2%
associate-/l*52.9%
unpow252.9%
Simplified52.9%
div-inv52.9%
Applied egg-rr52.9%
Taylor expanded in alpha around 0 53.3%
unpow253.3%
associate-/l*53.3%
associate-/r/53.3%
Simplified53.3%
if 3.2999999999999999e69 < beta < 2.3599999999999999e173Initial program 4.0%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.4%
Simplified32.1%
Taylor expanded in i around inf 65.6%
if 2.3599999999999999e173 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified8.1%
Taylor expanded in beta around inf 14.0%
associate-/l*16.7%
unpow216.7%
Simplified16.7%
div-inv16.7%
Applied egg-rr16.7%
Taylor expanded in i around inf 14.2%
unpow214.2%
unpow214.2%
times-frac69.5%
Simplified69.5%
Final simplification74.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function.
(FPCore (alpha beta i)
:precision binary64
(if (<= beta 4.1e+63)
(+ 0.0625 (/ 0.015625 (* i i)))
(if (<= beta 3.3e+69)
(/ (* i i) (* beta beta))
(if (<= beta 2.45e+173) 0.0625 (* (/ i beta) (/ i beta))))))assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2.45e+173) {
tmp = 0.0625;
} else {
tmp = (i / beta) * (i / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 4.1d+63) then
tmp = 0.0625d0 + (0.015625d0 / (i * i))
else if (beta <= 3.3d+69) then
tmp = (i * i) / (beta * beta)
else if (beta <= 2.45d+173) then
tmp = 0.0625d0
else
tmp = (i / beta) * (i / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 4.1e+63) {
tmp = 0.0625 + (0.015625 / (i * i));
} else if (beta <= 3.3e+69) {
tmp = (i * i) / (beta * beta);
} else if (beta <= 2.45e+173) {
tmp = 0.0625;
} else {
tmp = (i / beta) * (i / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 4.1e+63: tmp = 0.0625 + (0.015625 / (i * i)) elif beta <= 3.3e+69: tmp = (i * i) / (beta * beta) elif beta <= 2.45e+173: tmp = 0.0625 else: tmp = (i / beta) * (i / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 4.1e+63) tmp = Float64(0.0625 + Float64(0.015625 / Float64(i * i))); elseif (beta <= 3.3e+69) tmp = Float64(Float64(i * i) / Float64(beta * beta)); elseif (beta <= 2.45e+173) tmp = 0.0625; else tmp = Float64(Float64(i / beta) * Float64(i / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 4.1e+63)
tmp = 0.0625 + (0.015625 / (i * i));
elseif (beta <= 3.3e+69)
tmp = (i * i) / (beta * beta);
elseif (beta <= 2.45e+173)
tmp = 0.0625;
else
tmp = (i / beta) * (i / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 4.1e+63], N[(0.0625 + N[(0.015625 / N[(i * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 3.3e+69], N[(N[(i * i), $MachinePrecision] / N[(beta * beta), $MachinePrecision]), $MachinePrecision], If[LessEqual[beta, 2.45e+173], 0.0625, N[(N[(i / beta), $MachinePrecision] * N[(i / beta), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 4.1 \cdot 10^{+63}:\\
\;\;\;\;0.0625 + \frac{0.015625}{i \cdot i}\\
\mathbf{elif}\;\beta \leq 3.3 \cdot 10^{+69}:\\
\;\;\;\;\frac{i \cdot i}{\beta \cdot \beta}\\
\mathbf{elif}\;\beta \leq 2.45 \cdot 10^{+173}:\\
\;\;\;\;0.0625\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{i}{\beta}\\
\end{array}
\end{array}
if beta < 4.09999999999999993e63Initial program 21.7%
associate-/l/20.4%
associate-*l*20.3%
times-frac26.5%
Simplified50.1%
Taylor expanded in alpha around 0 18.4%
times-frac40.9%
unpow240.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
sub-neg40.9%
+-commutative40.9%
*-commutative40.9%
fma-udef40.9%
metadata-eval40.9%
Simplified40.9%
Taylor expanded in i around inf 76.9%
associate--l+76.9%
associate-*r/76.9%
unpow276.9%
unpow276.9%
associate-*r/76.9%
Simplified76.9%
Taylor expanded in beta around 0 77.0%
unpow277.0%
Simplified77.0%
if 4.09999999999999993e63 < beta < 3.2999999999999999e69Initial program 74.1%
associate-/l/74.1%
associate-*l*74.1%
times-frac73.7%
Simplified73.7%
Taylor expanded in beta around inf 53.2%
associate-/l*52.9%
unpow252.9%
Simplified52.9%
Taylor expanded in i around inf 53.7%
unpow253.7%
unpow253.7%
Simplified53.7%
if 3.2999999999999999e69 < beta < 2.45e173Initial program 4.0%
associate-/l/0.1%
associate-*l*0.1%
times-frac13.4%
Simplified32.1%
Taylor expanded in i around inf 65.6%
if 2.45e173 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified8.1%
Taylor expanded in beta around inf 14.0%
associate-/l*16.7%
unpow216.7%
Simplified16.7%
div-inv16.7%
Applied egg-rr16.7%
Taylor expanded in i around inf 14.2%
unpow214.2%
unpow214.2%
times-frac69.5%
Simplified69.5%
Final simplification74.1%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta i) :precision binary64 (if (<= beta 2.25e+198) 0.0625 (* (/ i beta) (/ alpha beta))))
assert(alpha < beta);
double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 2.25e+198) {
tmp = 0.0625;
} else {
tmp = (i / beta) * (alpha / beta);
}
return tmp;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
real(8) :: tmp
if (beta <= 2.25d+198) then
tmp = 0.0625d0
else
tmp = (i / beta) * (alpha / beta)
end if
code = tmp
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
double tmp;
if (beta <= 2.25e+198) {
tmp = 0.0625;
} else {
tmp = (i / beta) * (alpha / beta);
}
return tmp;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): tmp = 0 if beta <= 2.25e+198: tmp = 0.0625 else: tmp = (i / beta) * (alpha / beta) return tmp
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) tmp = 0.0 if (beta <= 2.25e+198) tmp = 0.0625; else tmp = Float64(Float64(i / beta) * Float64(alpha / beta)); end return tmp end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp_2 = code(alpha, beta, i)
tmp = 0.0;
if (beta <= 2.25e+198)
tmp = 0.0625;
else
tmp = (i / beta) * (alpha / beta);
end
tmp_2 = tmp;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := If[LessEqual[beta, 2.25e+198], 0.0625, N[(N[(i / beta), $MachinePrecision] * N[(alpha / beta), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
\begin{array}{l}
\mathbf{if}\;\beta \leq 2.25 \cdot 10^{+198}:\\
\;\;\;\;0.0625\\
\mathbf{else}:\\
\;\;\;\;\frac{i}{\beta} \cdot \frac{\alpha}{\beta}\\
\end{array}
\end{array}
if beta < 2.25000000000000001e198Initial program 19.7%
associate-/l/18.2%
associate-*l*18.1%
times-frac25.0%
Simplified47.2%
Taylor expanded in i around inf 72.7%
if 2.25000000000000001e198 < beta Initial program 0.0%
associate-/l/0.0%
associate-*l*0.0%
times-frac0.0%
Simplified8.5%
Taylor expanded in beta around inf 15.0%
associate-/l*18.0%
unpow218.0%
Simplified18.0%
div-inv18.0%
Applied egg-rr18.0%
Taylor expanded in beta around 0 15.0%
+-commutative15.0%
unpow215.0%
times-frac73.8%
+-commutative73.8%
Simplified73.8%
Taylor expanded in i around 0 17.2%
*-commutative17.2%
unpow217.2%
times-frac26.1%
Simplified26.1%
Final simplification66.2%
NOTE: alpha and beta should be sorted in increasing order before calling this function. (FPCore (alpha beta i) :precision binary64 0.0625)
assert(alpha < beta);
double code(double alpha, double beta, double i) {
return 0.0625;
}
NOTE: alpha and beta should be sorted in increasing order before calling this function.
real(8) function code(alpha, beta, i)
real(8), intent (in) :: alpha
real(8), intent (in) :: beta
real(8), intent (in) :: i
code = 0.0625d0
end function
assert alpha < beta;
public static double code(double alpha, double beta, double i) {
return 0.0625;
}
[alpha, beta] = sort([alpha, beta]) def code(alpha, beta, i): return 0.0625
alpha, beta = sort([alpha, beta]) function code(alpha, beta, i) return 0.0625 end
alpha, beta = num2cell(sort([alpha, beta])){:}
function tmp = code(alpha, beta, i)
tmp = 0.0625;
end
NOTE: alpha and beta should be sorted in increasing order before calling this function. code[alpha_, beta_, i_] := 0.0625
\begin{array}{l}
[alpha, beta] = \mathsf{sort}([alpha, beta])\\
\\
0.0625
\end{array}
Initial program 17.0%
associate-/l/15.6%
associate-*l*15.5%
times-frac21.5%
Simplified41.7%
Taylor expanded in i around inf 64.6%
Final simplification64.6%
herbie shell --seed 2023283
(FPCore (alpha beta i)
:name "Octave 3.8, jcobi/4"
:precision binary64
:pre (and (and (> alpha -1.0) (> beta -1.0)) (> i 1.0))
(/ (/ (* (* i (+ (+ alpha beta) i)) (+ (* beta alpha) (* i (+ (+ alpha beta) i)))) (* (+ (+ alpha beta) (* 2.0 i)) (+ (+ alpha beta) (* 2.0 i)))) (- (* (+ (+ alpha beta) (* 2.0 i)) (+ (+ alpha beta) (* 2.0 i))) 1.0)))