
(FPCore (n U t l Om U*) :precision binary64 (sqrt (* (* (* 2.0 n) U) (- (- t (* 2.0 (/ (* l l) Om))) (* (* n (pow (/ l Om) 2.0)) (- U U*))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * pow((l / Om), 2.0)) * (U - U_42_)))));
}
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt((((2.0d0 * n) * u) * ((t - (2.0d0 * ((l * l) / om))) - ((n * ((l / om) ** 2.0d0)) * (u - u_42)))))
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * Math.pow((l / Om), 2.0)) * (U - U_42_)))));
}
def code(n, U, t, l, Om, U_42_): return math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * math.pow((l / Om), 2.0)) * (U - U_42_)))))
function code(n, U, t, l, Om, U_42_) return sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) - Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U - U_42_))))) end
function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * ((l / Om) ^ 2.0)) * (U - U_42_))))); end
code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) - \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U - U*\right)\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (n U t l Om U*) :precision binary64 (sqrt (* (* (* 2.0 n) U) (- (- t (* 2.0 (/ (* l l) Om))) (* (* n (pow (/ l Om) 2.0)) (- U U*))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * pow((l / Om), 2.0)) * (U - U_42_)))));
}
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt((((2.0d0 * n) * u) * ((t - (2.0d0 * ((l * l) / om))) - ((n * ((l / om) ** 2.0d0)) * (u - u_42)))))
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * Math.pow((l / Om), 2.0)) * (U - U_42_)))));
}
def code(n, U, t, l, Om, U_42_): return math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * math.pow((l / Om), 2.0)) * (U - U_42_)))))
function code(n, U, t, l, Om, U_42_) return sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) - Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U - U_42_))))) end
function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * ((l / Om) ^ 2.0)) * (U - U_42_))))); end
code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) - \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U - U*\right)\right)}
\end{array}
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 3.55e+165)
(sqrt
(*
U
(*
(fma (/ l_m Om) (fma (- U* U) (* (/ l_m Om) n) (* l_m -2.0)) t)
(* n 2.0))))
(*
(sqrt (/ (* (* U n) (fma n (/ (- U* U) Om) -2.0)) Om))
(* l_m (sqrt 2.0)))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 3.55e+165) {
tmp = sqrt((U * (fma((l_m / Om), fma((U_42_ - U), ((l_m / Om) * n), (l_m * -2.0)), t) * (n * 2.0))));
} else {
tmp = sqrt((((U * n) * fma(n, ((U_42_ - U) / Om), -2.0)) / Om)) * (l_m * sqrt(2.0));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 3.55e+165) tmp = sqrt(Float64(U * Float64(fma(Float64(l_m / Om), fma(Float64(U_42_ - U), Float64(Float64(l_m / Om) * n), Float64(l_m * -2.0)), t) * Float64(n * 2.0)))); else tmp = Float64(sqrt(Float64(Float64(Float64(U * n) * fma(n, Float64(Float64(U_42_ - U) / Om), -2.0)) / Om)) * Float64(l_m * sqrt(2.0))); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 3.55e+165], N[Sqrt[N[(U * N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * n), $MachinePrecision] + N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision] * N[(n * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(N[(N[(U * n), $MachinePrecision] * N[(n * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision] * N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 3.55 \cdot 10^{+165}:\\
\;\;\;\;\sqrt{U \cdot \left(\mathsf{fma}\left(\frac{l\_m}{Om}, \mathsf{fma}\left(U* - U, \frac{l\_m}{Om} \cdot n, l\_m \cdot -2\right), t\right) \cdot \left(n \cdot 2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(U \cdot n\right) \cdot \mathsf{fma}\left(n, \frac{U* - U}{Om}, -2\right)}{Om}} \cdot \left(l\_m \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if l < 3.54999999999999988e165Initial program 47.2%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr51.9%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr59.9%
if 3.54999999999999988e165 < l Initial program 28.7%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr33.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr47.2%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified61.6%
Taylor expanded in l around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6473.6
Simplified73.6%
Final simplification61.1%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 4.5e-62)
(sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (/ (* U* (* l_m n)) Om) t))))
(if (<= l_m 4.8e+76)
(sqrt
(*
(* U (* n 2.0))
(- t (/ (* (* l_m l_m) (fma n (/ (- U U*) Om) 2.0)) Om))))
(if (<= l_m 4.8e+144)
(sqrt
(*
(/ (* (* U 2.0) (* n (* l_m l_m))) Om)
(/ (fma (- U* U) n (* Om -2.0)) Om)))
(*
(sqrt (/ (* (* U n) (fma n (/ (- U* U) Om) -2.0)) Om))
(* l_m (sqrt 2.0)))))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 4.5e-62) {
tmp = sqrt((U * ((n * 2.0) * fma((l_m / Om), ((U_42_ * (l_m * n)) / Om), t))));
} else if (l_m <= 4.8e+76) {
tmp = sqrt(((U * (n * 2.0)) * (t - (((l_m * l_m) * fma(n, ((U - U_42_) / Om), 2.0)) / Om))));
} else if (l_m <= 4.8e+144) {
tmp = sqrt(((((U * 2.0) * (n * (l_m * l_m))) / Om) * (fma((U_42_ - U), n, (Om * -2.0)) / Om)));
} else {
tmp = sqrt((((U * n) * fma(n, ((U_42_ - U) / Om), -2.0)) / Om)) * (l_m * sqrt(2.0));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 4.5e-62) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(Float64(U_42_ * Float64(l_m * n)) / Om), t)))); elseif (l_m <= 4.8e+76) tmp = sqrt(Float64(Float64(U * Float64(n * 2.0)) * Float64(t - Float64(Float64(Float64(l_m * l_m) * fma(n, Float64(Float64(U - U_42_) / Om), 2.0)) / Om)))); elseif (l_m <= 4.8e+144) tmp = sqrt(Float64(Float64(Float64(Float64(U * 2.0) * Float64(n * Float64(l_m * l_m))) / Om) * Float64(fma(Float64(U_42_ - U), n, Float64(Om * -2.0)) / Om))); else tmp = Float64(sqrt(Float64(Float64(Float64(U * n) * fma(n, Float64(Float64(U_42_ - U) / Om), -2.0)) / Om)) * Float64(l_m * sqrt(2.0))); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 4.5e-62], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(N[(U$42$ * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 4.8e+76], N[Sqrt[N[(N[(U * N[(n * 2.0), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(n * N[(N[(U - U$42$), $MachinePrecision] / Om), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 4.8e+144], N[Sqrt[N[(N[(N[(N[(U * 2.0), $MachinePrecision] * N[(n * N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] * N[(N[(N[(U$42$ - U), $MachinePrecision] * n + N[(Om * -2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(N[(N[(U * n), $MachinePrecision] * N[(n * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision] * N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 4.5 \cdot 10^{-62}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, \frac{U* \cdot \left(l\_m \cdot n\right)}{Om}, t\right)\right)}\\
\mathbf{elif}\;l\_m \leq 4.8 \cdot 10^{+76}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(n \cdot 2\right)\right) \cdot \left(t - \frac{\left(l\_m \cdot l\_m\right) \cdot \mathsf{fma}\left(n, \frac{U - U*}{Om}, 2\right)}{Om}\right)}\\
\mathbf{elif}\;l\_m \leq 4.8 \cdot 10^{+144}:\\
\;\;\;\;\sqrt{\frac{\left(U \cdot 2\right) \cdot \left(n \cdot \left(l\_m \cdot l\_m\right)\right)}{Om} \cdot \frac{\mathsf{fma}\left(U* - U, n, Om \cdot -2\right)}{Om}}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(U \cdot n\right) \cdot \mathsf{fma}\left(n, \frac{U* - U}{Om}, -2\right)}{Om}} \cdot \left(l\_m \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if l < 4.50000000000000018e-62Initial program 47.1%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr51.4%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr59.1%
Taylor expanded in U* around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6449.1
Simplified49.1%
if 4.50000000000000018e-62 < l < 4.8e76Initial program 61.0%
Taylor expanded in t around 0
--lowering--.f64N/A
+-commutativeN/A
unpow2N/A
associate-/r*N/A
metadata-evalN/A
cancel-sign-sub-invN/A
associate-*r/N/A
div-subN/A
/-lowering-/.f64N/A
Simplified75.5%
if 4.8e76 < l < 4.8000000000000001e144Initial program 33.8%
Taylor expanded in Om around 0
/-lowering-/.f64N/A
Simplified14.2%
Taylor expanded in l around inf
associate-*r/N/A
/-lowering-/.f64N/A
Simplified50.0%
associate-*r*N/A
associate-*r*N/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
Applied egg-rr61.2%
if 4.8000000000000001e144 < l Initial program 30.8%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr38.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr53.2%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified61.6%
Taylor expanded in l around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6467.7
Simplified67.7%
Final simplification53.9%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(let* ((t_1
(sqrt
(* U (* (* n 2.0) (fma (/ l_m Om) (/ (* U* (* l_m n)) Om) t))))))
(if (<= n -1.52e-62)
t_1
(if (<= n -4e-311)
(sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (* l_m -2.0) t))))
(if (<= n 4.2e-54)
(* (sqrt n) (sqrt (* (* U 2.0) (fma -2.0 (/ (* l_m l_m) Om) t))))
t_1)))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double t_1 = sqrt((U * ((n * 2.0) * fma((l_m / Om), ((U_42_ * (l_m * n)) / Om), t))));
double tmp;
if (n <= -1.52e-62) {
tmp = t_1;
} else if (n <= -4e-311) {
tmp = sqrt((U * ((n * 2.0) * fma((l_m / Om), (l_m * -2.0), t))));
} else if (n <= 4.2e-54) {
tmp = sqrt(n) * sqrt(((U * 2.0) * fma(-2.0, ((l_m * l_m) / Om), t)));
} else {
tmp = t_1;
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) t_1 = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(Float64(U_42_ * Float64(l_m * n)) / Om), t)))) tmp = 0.0 if (n <= -1.52e-62) tmp = t_1; elseif (n <= -4e-311) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(l_m * -2.0), t)))); elseif (n <= 4.2e-54) tmp = Float64(sqrt(n) * sqrt(Float64(Float64(U * 2.0) * fma(-2.0, Float64(Float64(l_m * l_m) / Om), t)))); else tmp = t_1; end return tmp end
l_m = N[Abs[l], $MachinePrecision]
code[n_, U_, t_, l$95$m_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(N[(U$42$ * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[n, -1.52e-62], t$95$1, If[LessEqual[n, -4e-311], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[n, 4.2e-54], N[(N[Sqrt[n], $MachinePrecision] * N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(-2.0 * N[(N[(l$95$m * l$95$m), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := \sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, \frac{U* \cdot \left(l\_m \cdot n\right)}{Om}, t\right)\right)}\\
\mathbf{if}\;n \leq -1.52 \cdot 10^{-62}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;n \leq -4 \cdot 10^{-311}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, l\_m \cdot -2, t\right)\right)}\\
\mathbf{elif}\;n \leq 4.2 \cdot 10^{-54}:\\
\;\;\;\;\sqrt{n} \cdot \sqrt{\left(U \cdot 2\right) \cdot \mathsf{fma}\left(-2, \frac{l\_m \cdot l\_m}{Om}, t\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if n < -1.52000000000000007e-62 or 4.2e-54 < n Initial program 55.6%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr61.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr66.8%
Taylor expanded in U* around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6460.4
Simplified60.4%
if -1.52000000000000007e-62 < n < -3.99999999999979e-311Initial program 40.5%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr44.1%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr58.1%
Taylor expanded in n around 0
*-lowering-*.f6456.9
Simplified56.9%
if -3.99999999999979e-311 < n < 4.2e-54Initial program 29.1%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
sqrt-prodN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Applied egg-rr43.7%
Taylor expanded in Om around inf
+-commutativeN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6447.9
Simplified47.9%
Final simplification56.6%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 8e-61)
(sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (/ (* U* (* l_m n)) Om) t))))
(if (<= l_m 2.15e+77)
(sqrt
(*
(* U (* n 2.0))
(- t (/ (* (* l_m l_m) (fma n (/ (- U U*) Om) 2.0)) Om))))
(sqrt
(/
(* (* (* l_m n) (* U 2.0)) (* l_m (fma n (/ (- U* U) Om) -2.0)))
Om)))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 8e-61) {
tmp = sqrt((U * ((n * 2.0) * fma((l_m / Om), ((U_42_ * (l_m * n)) / Om), t))));
} else if (l_m <= 2.15e+77) {
tmp = sqrt(((U * (n * 2.0)) * (t - (((l_m * l_m) * fma(n, ((U - U_42_) / Om), 2.0)) / Om))));
} else {
tmp = sqrt(((((l_m * n) * (U * 2.0)) * (l_m * fma(n, ((U_42_ - U) / Om), -2.0))) / Om));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 8e-61) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(Float64(U_42_ * Float64(l_m * n)) / Om), t)))); elseif (l_m <= 2.15e+77) tmp = sqrt(Float64(Float64(U * Float64(n * 2.0)) * Float64(t - Float64(Float64(Float64(l_m * l_m) * fma(n, Float64(Float64(U - U_42_) / Om), 2.0)) / Om)))); else tmp = sqrt(Float64(Float64(Float64(Float64(l_m * n) * Float64(U * 2.0)) * Float64(l_m * fma(n, Float64(Float64(U_42_ - U) / Om), -2.0))) / Om)); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 8e-61], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(N[(U$42$ * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 2.15e+77], N[Sqrt[N[(N[(U * N[(n * 2.0), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(n * N[(N[(U - U$42$), $MachinePrecision] / Om), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(N[(N[(l$95$m * n), $MachinePrecision] * N[(U * 2.0), $MachinePrecision]), $MachinePrecision] * N[(l$95$m * N[(n * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 8 \cdot 10^{-61}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, \frac{U* \cdot \left(l\_m \cdot n\right)}{Om}, t\right)\right)}\\
\mathbf{elif}\;l\_m \leq 2.15 \cdot 10^{+77}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(n \cdot 2\right)\right) \cdot \left(t - \frac{\left(l\_m \cdot l\_m\right) \cdot \mathsf{fma}\left(n, \frac{U - U*}{Om}, 2\right)}{Om}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(\left(l\_m \cdot n\right) \cdot \left(U \cdot 2\right)\right) \cdot \left(l\_m \cdot \mathsf{fma}\left(n, \frac{U* - U}{Om}, -2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 8.0000000000000003e-61Initial program 47.1%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr51.4%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr59.1%
Taylor expanded in U* around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6449.1
Simplified49.1%
if 8.0000000000000003e-61 < l < 2.14999999999999996e77Initial program 61.0%
Taylor expanded in t around 0
--lowering--.f64N/A
+-commutativeN/A
unpow2N/A
associate-/r*N/A
metadata-evalN/A
cancel-sign-sub-invN/A
associate-*r/N/A
div-subN/A
/-lowering-/.f64N/A
Simplified75.5%
if 2.14999999999999996e77 < l Initial program 31.9%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr36.8%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr51.9%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified54.9%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r/N/A
associate-*l/N/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr61.4%
Final simplification53.3%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 4.3e+144)
(sqrt
(*
U
(*
(* n 2.0)
(fma (fma (- U* U) (/ (* l_m n) Om) (* l_m -2.0)) (/ l_m Om) t))))
(*
(sqrt (/ (* (* U n) (fma n (/ (- U* U) Om) -2.0)) Om))
(* l_m (sqrt 2.0)))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 4.3e+144) {
tmp = sqrt((U * ((n * 2.0) * fma(fma((U_42_ - U), ((l_m * n) / Om), (l_m * -2.0)), (l_m / Om), t))));
} else {
tmp = sqrt((((U * n) * fma(n, ((U_42_ - U) / Om), -2.0)) / Om)) * (l_m * sqrt(2.0));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 4.3e+144) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(fma(Float64(U_42_ - U), Float64(Float64(l_m * n) / Om), Float64(l_m * -2.0)), Float64(l_m / Om), t)))); else tmp = Float64(sqrt(Float64(Float64(Float64(U * n) * fma(n, Float64(Float64(U_42_ - U) / Om), -2.0)) / Om)) * Float64(l_m * sqrt(2.0))); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 4.3e+144], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(N[(U$42$ - U), $MachinePrecision] * N[(N[(l$95$m * n), $MachinePrecision] / Om), $MachinePrecision] + N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision] * N[(l$95$m / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(N[(N[(U * n), $MachinePrecision] * N[(n * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision] * N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 4.3 \cdot 10^{+144}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(U* - U, \frac{l\_m \cdot n}{Om}, l\_m \cdot -2\right), \frac{l\_m}{Om}, t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(U \cdot n\right) \cdot \mathsf{fma}\left(n, \frac{U* - U}{Om}, -2\right)}{Om}} \cdot \left(l\_m \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if l < 4.29999999999999984e144Initial program 47.4%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr51.8%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr59.4%
*-commutativeN/A
accelerator-lowering-fma.f64N/A
accelerator-lowering-fma.f64N/A
associate--r-N/A
neg-sub0N/A
+-commutativeN/A
sub-negN/A
--lowering--.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6458.8
Applied egg-rr58.8%
if 4.29999999999999984e144 < l Initial program 30.8%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr38.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr53.2%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified61.6%
Taylor expanded in l around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6467.7
Simplified67.7%
Final simplification59.8%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(let* ((t_1 (sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (* l_m -2.0) t))))))
(if (<= Om -4.4e+22)
t_1
(if (<= Om 6.6e-36)
(sqrt (/ (* 2.0 (* U (* (* l_m n) (/ (* U* (* l_m n)) Om)))) Om))
t_1))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double t_1 = sqrt((U * ((n * 2.0) * fma((l_m / Om), (l_m * -2.0), t))));
double tmp;
if (Om <= -4.4e+22) {
tmp = t_1;
} else if (Om <= 6.6e-36) {
tmp = sqrt(((2.0 * (U * ((l_m * n) * ((U_42_ * (l_m * n)) / Om)))) / Om));
} else {
tmp = t_1;
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) t_1 = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(l_m * -2.0), t)))) tmp = 0.0 if (Om <= -4.4e+22) tmp = t_1; elseif (Om <= 6.6e-36) tmp = sqrt(Float64(Float64(2.0 * Float64(U * Float64(Float64(l_m * n) * Float64(Float64(U_42_ * Float64(l_m * n)) / Om)))) / Om)); else tmp = t_1; end return tmp end
l_m = N[Abs[l], $MachinePrecision]
code[n_, U_, t_, l$95$m_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[Om, -4.4e+22], t$95$1, If[LessEqual[Om, 6.6e-36], N[Sqrt[N[(N[(2.0 * N[(U * N[(N[(l$95$m * n), $MachinePrecision] * N[(N[(U$42$ * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision], t$95$1]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := \sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, l\_m \cdot -2, t\right)\right)}\\
\mathbf{if}\;Om \leq -4.4 \cdot 10^{+22}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;Om \leq 6.6 \cdot 10^{-36}:\\
\;\;\;\;\sqrt{\frac{2 \cdot \left(U \cdot \left(\left(l\_m \cdot n\right) \cdot \frac{U* \cdot \left(l\_m \cdot n\right)}{Om}\right)\right)}{Om}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if Om < -4.4e22 or 6.59999999999999981e-36 < Om Initial program 52.1%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr58.8%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr63.7%
Taylor expanded in n around 0
*-lowering-*.f6458.5
Simplified58.5%
if -4.4e22 < Om < 6.59999999999999981e-36Initial program 36.3%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr38.3%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr51.8%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified44.5%
Taylor expanded in U* around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6445.8
Simplified45.8%
Final simplification53.3%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 8.5e+52)
(sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (/ (* U* (* l_m n)) Om) t))))
(sqrt
(/ (* (* (* l_m n) (* U 2.0)) (* l_m (fma n (/ (- U* U) Om) -2.0))) Om))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 8.5e+52) {
tmp = sqrt((U * ((n * 2.0) * fma((l_m / Om), ((U_42_ * (l_m * n)) / Om), t))));
} else {
tmp = sqrt(((((l_m * n) * (U * 2.0)) * (l_m * fma(n, ((U_42_ - U) / Om), -2.0))) / Om));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 8.5e+52) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(Float64(U_42_ * Float64(l_m * n)) / Om), t)))); else tmp = sqrt(Float64(Float64(Float64(Float64(l_m * n) * Float64(U * 2.0)) * Float64(l_m * fma(n, Float64(Float64(U_42_ - U) / Om), -2.0))) / Om)); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 8.5e+52], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(N[(U$42$ * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(N[(N[(l$95$m * n), $MachinePrecision] * N[(U * 2.0), $MachinePrecision]), $MachinePrecision] * N[(l$95$m * N[(n * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 8.5 \cdot 10^{+52}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, \frac{U* \cdot \left(l\_m \cdot n\right)}{Om}, t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(\left(l\_m \cdot n\right) \cdot \left(U \cdot 2\right)\right) \cdot \left(l\_m \cdot \mathsf{fma}\left(n, \frac{U* - U}{Om}, -2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 8.49999999999999994e52Initial program 48.4%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr53.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr60.3%
Taylor expanded in U* around inf
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6450.7
Simplified50.7%
if 8.49999999999999994e52 < l Initial program 32.8%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr37.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr51.9%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified52.6%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r/N/A
associate-*l/N/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr58.8%
Final simplification52.2%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U -2e-311) (sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (* l_m -2.0) t)))) (* (sqrt (* n (fma l_m (/ (* l_m -2.0) Om) t))) (sqrt (* U 2.0)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (U <= -2e-311) {
tmp = sqrt((U * ((n * 2.0) * fma((l_m / Om), (l_m * -2.0), t))));
} else {
tmp = sqrt((n * fma(l_m, ((l_m * -2.0) / Om), t))) * sqrt((U * 2.0));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U <= -2e-311) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(l_m * -2.0), t)))); else tmp = Float64(sqrt(Float64(n * fma(l_m, Float64(Float64(l_m * -2.0) / Om), t))) * sqrt(Float64(U * 2.0))); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[U, -2e-311], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(n * N[(l$95$m * N[(N[(l$95$m * -2.0), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(U * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U \leq -2 \cdot 10^{-311}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, l\_m \cdot -2, t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \mathsf{fma}\left(l\_m, \frac{l\_m \cdot -2}{Om}, t\right)} \cdot \sqrt{U \cdot 2}\\
\end{array}
\end{array}
if U < -1.9999999999999e-311Initial program 48.3%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr50.8%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr59.7%
Taylor expanded in n around 0
*-lowering-*.f6447.6
Simplified47.6%
if -1.9999999999999e-311 < U Initial program 43.1%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr50.0%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr58.0%
Taylor expanded in n around 0
*-lowering-*.f6443.8
Simplified43.8%
pow1/2N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr53.5%
Final simplification50.7%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= n -4e-311) (sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (* l_m -2.0) t)))) (* (sqrt n) (sqrt (* (* U 2.0) (fma -2.0 (/ (* l_m l_m) Om) t))))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (n <= -4e-311) {
tmp = sqrt((U * ((n * 2.0) * fma((l_m / Om), (l_m * -2.0), t))));
} else {
tmp = sqrt(n) * sqrt(((U * 2.0) * fma(-2.0, ((l_m * l_m) / Om), t)));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (n <= -4e-311) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(l_m * -2.0), t)))); else tmp = Float64(sqrt(n) * sqrt(Float64(Float64(U * 2.0) * fma(-2.0, Float64(Float64(l_m * l_m) / Om), t)))); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[n, -4e-311], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[n], $MachinePrecision] * N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(-2.0 * N[(N[(l$95$m * l$95$m), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;n \leq -4 \cdot 10^{-311}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, l\_m \cdot -2, t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n} \cdot \sqrt{\left(U \cdot 2\right) \cdot \mathsf{fma}\left(-2, \frac{l\_m \cdot l\_m}{Om}, t\right)}\\
\end{array}
\end{array}
if n < -3.99999999999979e-311Initial program 48.2%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr52.8%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr60.8%
Taylor expanded in n around 0
*-lowering-*.f6448.3
Simplified48.3%
if -3.99999999999979e-311 < n Initial program 42.8%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
sqrt-prodN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Applied egg-rr45.2%
Taylor expanded in Om around inf
+-commutativeN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6448.1
Simplified48.1%
Final simplification48.2%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 2.3e-74)
(sqrt (* (* U 2.0) (* n t)))
(if (<= l_m 1.7e+130)
(sqrt (* (* U (* n 2.0)) (fma -2.0 (/ (* l_m l_m) Om) t)))
(sqrt (/ (* 2.0 (* U (* (* l_m -2.0) (* l_m n)))) Om)))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 2.3e-74) {
tmp = sqrt(((U * 2.0) * (n * t)));
} else if (l_m <= 1.7e+130) {
tmp = sqrt(((U * (n * 2.0)) * fma(-2.0, ((l_m * l_m) / Om), t)));
} else {
tmp = sqrt(((2.0 * (U * ((l_m * -2.0) * (l_m * n)))) / Om));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 2.3e-74) tmp = sqrt(Float64(Float64(U * 2.0) * Float64(n * t))); elseif (l_m <= 1.7e+130) tmp = sqrt(Float64(Float64(U * Float64(n * 2.0)) * fma(-2.0, Float64(Float64(l_m * l_m) / Om), t))); else tmp = sqrt(Float64(Float64(2.0 * Float64(U * Float64(Float64(l_m * -2.0) * Float64(l_m * n)))) / Om)); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 2.3e-74], N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 1.7e+130], N[Sqrt[N[(N[(U * N[(n * 2.0), $MachinePrecision]), $MachinePrecision] * N[(-2.0 * N[(N[(l$95$m * l$95$m), $MachinePrecision] / Om), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(U * N[(N[(l$95$m * -2.0), $MachinePrecision] * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 2.3 \cdot 10^{-74}:\\
\;\;\;\;\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}\\
\mathbf{elif}\;l\_m \leq 1.7 \cdot 10^{+130}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(n \cdot 2\right)\right) \cdot \mathsf{fma}\left(-2, \frac{l\_m \cdot l\_m}{Om}, t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{2 \cdot \left(U \cdot \left(\left(l\_m \cdot -2\right) \cdot \left(l\_m \cdot n\right)\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 2.2999999999999998e-74Initial program 46.9%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6438.4
Simplified38.4%
if 2.2999999999999998e-74 < l < 1.7e130Initial program 52.5%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr58.0%
Taylor expanded in n around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6438.3
Simplified38.3%
if 1.7e130 < l Initial program 28.8%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr36.0%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr53.1%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified60.8%
Taylor expanded in n around 0
*-lowering-*.f6454.1
Simplified54.1%
Final simplification40.1%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= l_m 2.45e+120) (sqrt (* U (* (* n 2.0) (fma (/ l_m Om) (* l_m -2.0) t)))) (sqrt (/ (* 2.0 (* U (* (* l_m -2.0) (* l_m n)))) Om))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 2.45e+120) {
tmp = sqrt((U * ((n * 2.0) * fma((l_m / Om), (l_m * -2.0), t))));
} else {
tmp = sqrt(((2.0 * (U * ((l_m * -2.0) * (l_m * n)))) / Om));
}
return tmp;
}
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 2.45e+120) tmp = sqrt(Float64(U * Float64(Float64(n * 2.0) * fma(Float64(l_m / Om), Float64(l_m * -2.0), t)))); else tmp = sqrt(Float64(Float64(2.0 * Float64(U * Float64(Float64(l_m * -2.0) * Float64(l_m * n)))) / Om)); end return tmp end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 2.45e+120], N[Sqrt[N[(U * N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(U * N[(N[(l$95$m * -2.0), $MachinePrecision] * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 2.45 \cdot 10^{+120}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(n \cdot 2\right) \cdot \mathsf{fma}\left(\frac{l\_m}{Om}, l\_m \cdot -2, t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{2 \cdot \left(U \cdot \left(\left(l\_m \cdot -2\right) \cdot \left(l\_m \cdot n\right)\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 2.45000000000000005e120Initial program 48.2%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr52.6%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr60.0%
Taylor expanded in n around 0
*-lowering-*.f6446.2
Simplified46.2%
if 2.45000000000000005e120 < l Initial program 27.1%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr33.9%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr50.0%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified57.2%
Taylor expanded in n around 0
*-lowering-*.f6450.8
Simplified50.8%
Final simplification46.8%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= l_m 4.4e+52) (sqrt (* (* U 2.0) (* n t))) (sqrt (/ (* 2.0 (* U (* (* l_m -2.0) (* l_m n)))) Om))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 4.4e+52) {
tmp = sqrt(((U * 2.0) * (n * t)));
} else {
tmp = sqrt(((2.0 * (U * ((l_m * -2.0) * (l_m * n)))) / Om));
}
return tmp;
}
l_m = abs(l)
real(8) function code(n, u, t, l_m, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l_m
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l_m <= 4.4d+52) then
tmp = sqrt(((u * 2.0d0) * (n * t)))
else
tmp = sqrt(((2.0d0 * (u * ((l_m * (-2.0d0)) * (l_m * n)))) / om))
end if
code = tmp
end function
l_m = Math.abs(l);
public static double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 4.4e+52) {
tmp = Math.sqrt(((U * 2.0) * (n * t)));
} else {
tmp = Math.sqrt(((2.0 * (U * ((l_m * -2.0) * (l_m * n)))) / Om));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 4.4e+52: tmp = math.sqrt(((U * 2.0) * (n * t))) else: tmp = math.sqrt(((2.0 * (U * ((l_m * -2.0) * (l_m * n)))) / Om)) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 4.4e+52) tmp = sqrt(Float64(Float64(U * 2.0) * Float64(n * t))); else tmp = sqrt(Float64(Float64(2.0 * Float64(U * Float64(Float64(l_m * -2.0) * Float64(l_m * n)))) / Om)); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) tmp = 0.0; if (l_m <= 4.4e+52) tmp = sqrt(((U * 2.0) * (n * t))); else tmp = sqrt(((2.0 * (U * ((l_m * -2.0) * (l_m * n)))) / Om)); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 4.4e+52], N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(U * N[(N[(l$95$m * -2.0), $MachinePrecision] * N[(l$95$m * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 4.4 \cdot 10^{+52}:\\
\;\;\;\;\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{2 \cdot \left(U \cdot \left(\left(l\_m \cdot -2\right) \cdot \left(l\_m \cdot n\right)\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 4.4e52Initial program 48.4%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6437.9
Simplified37.9%
if 4.4e52 < l Initial program 32.8%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr37.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr51.9%
Taylor expanded in t around 0
associate-*r/N/A
/-lowering-/.f64N/A
Simplified52.6%
Taylor expanded in n around 0
*-lowering-*.f6445.9
Simplified45.9%
Final simplification39.3%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= l_m 3.5e+52) (sqrt (* (* U 2.0) (* n t))) (sqrt (/ (* (* U -4.0) (* n (* l_m l_m))) Om))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 3.5e+52) {
tmp = sqrt(((U * 2.0) * (n * t)));
} else {
tmp = sqrt((((U * -4.0) * (n * (l_m * l_m))) / Om));
}
return tmp;
}
l_m = abs(l)
real(8) function code(n, u, t, l_m, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l_m
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l_m <= 3.5d+52) then
tmp = sqrt(((u * 2.0d0) * (n * t)))
else
tmp = sqrt((((u * (-4.0d0)) * (n * (l_m * l_m))) / om))
end if
code = tmp
end function
l_m = Math.abs(l);
public static double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 3.5e+52) {
tmp = Math.sqrt(((U * 2.0) * (n * t)));
} else {
tmp = Math.sqrt((((U * -4.0) * (n * (l_m * l_m))) / Om));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 3.5e+52: tmp = math.sqrt(((U * 2.0) * (n * t))) else: tmp = math.sqrt((((U * -4.0) * (n * (l_m * l_m))) / Om)) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 3.5e+52) tmp = sqrt(Float64(Float64(U * 2.0) * Float64(n * t))); else tmp = sqrt(Float64(Float64(Float64(U * -4.0) * Float64(n * Float64(l_m * l_m))) / Om)); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) tmp = 0.0; if (l_m <= 3.5e+52) tmp = sqrt(((U * 2.0) * (n * t))); else tmp = sqrt((((U * -4.0) * (n * (l_m * l_m))) / Om)); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 3.5e+52], N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(N[(U * -4.0), $MachinePrecision] * N[(n * N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 3.5 \cdot 10^{+52}:\\
\;\;\;\;\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(U \cdot -4\right) \cdot \left(n \cdot \left(l\_m \cdot l\_m\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 3.5e52Initial program 48.4%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6437.9
Simplified37.9%
if 3.5e52 < l Initial program 32.8%
Taylor expanded in Om around 0
/-lowering-/.f64N/A
Simplified25.2%
Taylor expanded in l around inf
associate-*r/N/A
/-lowering-/.f64N/A
Simplified39.4%
Taylor expanded in n around 0
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6431.1
Simplified31.1%
Final simplification36.7%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= l_m 3.6e+52) (sqrt (* (* U 2.0) (* n t))) (sqrt (* U (/ (* -4.0 (* n (* l_m l_m))) Om)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 3.6e+52) {
tmp = sqrt(((U * 2.0) * (n * t)));
} else {
tmp = sqrt((U * ((-4.0 * (n * (l_m * l_m))) / Om)));
}
return tmp;
}
l_m = abs(l)
real(8) function code(n, u, t, l_m, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l_m
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l_m <= 3.6d+52) then
tmp = sqrt(((u * 2.0d0) * (n * t)))
else
tmp = sqrt((u * (((-4.0d0) * (n * (l_m * l_m))) / om)))
end if
code = tmp
end function
l_m = Math.abs(l);
public static double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (l_m <= 3.6e+52) {
tmp = Math.sqrt(((U * 2.0) * (n * t)));
} else {
tmp = Math.sqrt((U * ((-4.0 * (n * (l_m * l_m))) / Om)));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 3.6e+52: tmp = math.sqrt(((U * 2.0) * (n * t))) else: tmp = math.sqrt((U * ((-4.0 * (n * (l_m * l_m))) / Om))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 3.6e+52) tmp = sqrt(Float64(Float64(U * 2.0) * Float64(n * t))); else tmp = sqrt(Float64(U * Float64(Float64(-4.0 * Float64(n * Float64(l_m * l_m))) / Om))); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) tmp = 0.0; if (l_m <= 3.6e+52) tmp = sqrt(((U * 2.0) * (n * t))); else tmp = sqrt((U * ((-4.0 * (n * (l_m * l_m))) / Om))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[l$95$m, 3.6e+52], N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(U * N[(N[(-4.0 * N[(n * N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 3.6 \cdot 10^{+52}:\\
\;\;\;\;\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \frac{-4 \cdot \left(n \cdot \left(l\_m \cdot l\_m\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 3.6e52Initial program 48.4%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6437.9
Simplified37.9%
if 3.6e52 < l Initial program 32.8%
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
unpow2N/A
associate-*r*N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
neg-sub0N/A
metadata-evalN/A
--lowering--.f64N/A
metadata-evalN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
Applied egg-rr37.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr51.9%
Taylor expanded in n around 0
*-lowering-*.f6445.8
Simplified45.8%
Taylor expanded in l around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6431.2
Simplified31.2%
Final simplification36.7%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U -2e-311) (sqrt (* (* U 2.0) (* n t))) (* (sqrt (* U 2.0)) (sqrt (* n t)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (U <= -2e-311) {
tmp = sqrt(((U * 2.0) * (n * t)));
} else {
tmp = sqrt((U * 2.0)) * sqrt((n * t));
}
return tmp;
}
l_m = abs(l)
real(8) function code(n, u, t, l_m, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l_m
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (u <= (-2d-311)) then
tmp = sqrt(((u * 2.0d0) * (n * t)))
else
tmp = sqrt((u * 2.0d0)) * sqrt((n * t))
end if
code = tmp
end function
l_m = Math.abs(l);
public static double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (U <= -2e-311) {
tmp = Math.sqrt(((U * 2.0) * (n * t)));
} else {
tmp = Math.sqrt((U * 2.0)) * Math.sqrt((n * t));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U <= -2e-311: tmp = math.sqrt(((U * 2.0) * (n * t))) else: tmp = math.sqrt((U * 2.0)) * math.sqrt((n * t)) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U <= -2e-311) tmp = sqrt(Float64(Float64(U * 2.0) * Float64(n * t))); else tmp = Float64(sqrt(Float64(U * 2.0)) * sqrt(Float64(n * t))); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) tmp = 0.0; if (U <= -2e-311) tmp = sqrt(((U * 2.0) * (n * t))); else tmp = sqrt((U * 2.0)) * sqrt((n * t)); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[U, -2e-311], N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(U * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(n * t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U \leq -2 \cdot 10^{-311}:\\
\;\;\;\;\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot 2} \cdot \sqrt{n \cdot t}\\
\end{array}
\end{array}
if U < -1.9999999999999e-311Initial program 48.3%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6440.1
Simplified40.1%
if -1.9999999999999e-311 < U Initial program 43.1%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6428.0
Simplified28.0%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
*-commutativeN/A
*-lowering-*.f6436.2
Applied egg-rr36.2%
Final simplification38.1%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= t -4e-310) (sqrt (* (* U 2.0) (* n t))) (* (sqrt (* U (* n 2.0))) (sqrt t))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (t <= -4e-310) {
tmp = sqrt(((U * 2.0) * (n * t)));
} else {
tmp = sqrt((U * (n * 2.0))) * sqrt(t);
}
return tmp;
}
l_m = abs(l)
real(8) function code(n, u, t, l_m, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l_m
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (t <= (-4d-310)) then
tmp = sqrt(((u * 2.0d0) * (n * t)))
else
tmp = sqrt((u * (n * 2.0d0))) * sqrt(t)
end if
code = tmp
end function
l_m = Math.abs(l);
public static double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (t <= -4e-310) {
tmp = Math.sqrt(((U * 2.0) * (n * t)));
} else {
tmp = Math.sqrt((U * (n * 2.0))) * Math.sqrt(t);
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if t <= -4e-310: tmp = math.sqrt(((U * 2.0) * (n * t))) else: tmp = math.sqrt((U * (n * 2.0))) * math.sqrt(t) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (t <= -4e-310) tmp = sqrt(Float64(Float64(U * 2.0) * Float64(n * t))); else tmp = Float64(sqrt(Float64(U * Float64(n * 2.0))) * sqrt(t)); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) tmp = 0.0; if (t <= -4e-310) tmp = sqrt(((U * 2.0) * (n * t))); else tmp = sqrt((U * (n * 2.0))) * sqrt(t); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[t, -4e-310], N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(U * N[(n * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4 \cdot 10^{-310}:\\
\;\;\;\;\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(n \cdot 2\right)} \cdot \sqrt{t}\\
\end{array}
\end{array}
if t < -3.999999999999988e-310Initial program 46.0%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6434.0
Simplified34.0%
if -3.999999999999988e-310 < t Initial program 45.2%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6433.7
Simplified33.7%
pow1/2N/A
associate-*r*N/A
unpow-prod-downN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6440.3
Applied egg-rr40.3%
Final simplification36.9%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U -5e-73) (sqrt (* (* U 2.0) (* n t))) (sqrt (* n (* t (* U 2.0))))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (U <= -5e-73) {
tmp = sqrt(((U * 2.0) * (n * t)));
} else {
tmp = sqrt((n * (t * (U * 2.0))));
}
return tmp;
}
l_m = abs(l)
real(8) function code(n, u, t, l_m, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l_m
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (u <= (-5d-73)) then
tmp = sqrt(((u * 2.0d0) * (n * t)))
else
tmp = sqrt((n * (t * (u * 2.0d0))))
end if
code = tmp
end function
l_m = Math.abs(l);
public static double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (U <= -5e-73) {
tmp = Math.sqrt(((U * 2.0) * (n * t)));
} else {
tmp = Math.sqrt((n * (t * (U * 2.0))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U <= -5e-73: tmp = math.sqrt(((U * 2.0) * (n * t))) else: tmp = math.sqrt((n * (t * (U * 2.0)))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U <= -5e-73) tmp = sqrt(Float64(Float64(U * 2.0) * Float64(n * t))); else tmp = sqrt(Float64(n * Float64(t * Float64(U * 2.0)))); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) tmp = 0.0; if (U <= -5e-73) tmp = sqrt(((U * 2.0) * (n * t))); else tmp = sqrt((n * (t * (U * 2.0)))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[U, -5e-73], N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(t * N[(U * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U \leq -5 \cdot 10^{-73}:\\
\;\;\;\;\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \left(t \cdot \left(U \cdot 2\right)\right)}\\
\end{array}
\end{array}
if U < -4.9999999999999998e-73Initial program 58.3%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6451.2
Simplified51.2%
if -4.9999999999999998e-73 < U Initial program 41.7%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6428.5
Simplified28.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6430.7
Applied egg-rr30.7%
Final simplification35.5%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (sqrt (* (* U 2.0) (* n t))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
return sqrt(((U * 2.0) * (n * t)));
}
l_m = abs(l)
real(8) function code(n, u, t, l_m, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l_m
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt(((u * 2.0d0) * (n * t)))
end function
l_m = Math.abs(l);
public static double code(double n, double U, double t, double l_m, double Om, double U_42_) {
return Math.sqrt(((U * 2.0) * (n * t)));
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): return math.sqrt(((U * 2.0) * (n * t)))
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) return sqrt(Float64(Float64(U * 2.0) * Float64(n * t))) end
l_m = abs(l); function tmp = code(n, U, t, l_m, Om, U_42_) tmp = sqrt(((U * 2.0) * (n * t))); end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := N[Sqrt[N[(N[(U * 2.0), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\sqrt{\left(U \cdot 2\right) \cdot \left(n \cdot t\right)}
\end{array}
Initial program 45.6%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6433.8
Simplified33.8%
Final simplification33.8%
herbie shell --seed 2024197
(FPCore (n U t l Om U*)
:name "Toniolo and Linder, Equation (13)"
:precision binary64
(sqrt (* (* (* 2.0 n) U) (- (- t (* 2.0 (/ (* l l) Om))) (* (* n (pow (/ l Om) 2.0)) (- U U*))))))