
(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 15 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
(let* ((t_1
(*
(* U (* 2.0 n))
(+
(- t (* 2.0 (/ (* l_m l_m) Om)))
(* (* n (pow (/ l_m Om) 2.0)) (- U* U))))))
(if (<= t_1 0.0)
(sqrt
(*
U
(+
(* 2.0 (* n t))
(/
(* 2.0 (* (* n l_m) (+ (* l_m -2.0) (* U* (/ (* n l_m) Om)))))
Om))))
(if (<= t_1 1e+255)
(sqrt
(*
(* 2.0 (* n U))
(- t (* (/ l_m Om) (- (* (- U U*) (/ n (/ Om l_m))) (* l_m -2.0))))))
(*
(sqrt (* U (/ (* n (+ -2.0 (/ (* n U*) Om))) 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 t_1 = (U * (2.0 * n)) * ((t - (2.0 * ((l_m * l_m) / Om))) + ((n * pow((l_m / Om), 2.0)) * (U_42_ - U)));
double tmp;
if (t_1 <= 0.0) {
tmp = sqrt((U * ((2.0 * (n * t)) + ((2.0 * ((n * l_m) * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om))))) / Om))));
} else if (t_1 <= 1e+255) {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0))))));
} else {
tmp = sqrt((U * ((n * (-2.0 + ((n * U_42_) / Om))) / Om))) * (l_m * sqrt(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) :: t_1
real(8) :: tmp
t_1 = (u * (2.0d0 * n)) * ((t - (2.0d0 * ((l_m * l_m) / om))) + ((n * ((l_m / om) ** 2.0d0)) * (u_42 - u)))
if (t_1 <= 0.0d0) then
tmp = sqrt((u * ((2.0d0 * (n * t)) + ((2.0d0 * ((n * l_m) * ((l_m * (-2.0d0)) + (u_42 * ((n * l_m) / om))))) / om))))
else if (t_1 <= 1d+255) then
tmp = sqrt(((2.0d0 * (n * u)) * (t - ((l_m / om) * (((u - u_42) * (n / (om / l_m))) - (l_m * (-2.0d0)))))))
else
tmp = sqrt((u * ((n * ((-2.0d0) + ((n * u_42) / om))) / om))) * (l_m * sqrt(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 t_1 = (U * (2.0 * n)) * ((t - (2.0 * ((l_m * l_m) / Om))) + ((n * Math.pow((l_m / Om), 2.0)) * (U_42_ - U)));
double tmp;
if (t_1 <= 0.0) {
tmp = Math.sqrt((U * ((2.0 * (n * t)) + ((2.0 * ((n * l_m) * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om))))) / Om))));
} else if (t_1 <= 1e+255) {
tmp = Math.sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0))))));
} else {
tmp = Math.sqrt((U * ((n * (-2.0 + ((n * U_42_) / Om))) / Om))) * (l_m * Math.sqrt(2.0));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): t_1 = (U * (2.0 * n)) * ((t - (2.0 * ((l_m * l_m) / Om))) + ((n * math.pow((l_m / Om), 2.0)) * (U_42_ - U))) tmp = 0 if t_1 <= 0.0: tmp = math.sqrt((U * ((2.0 * (n * t)) + ((2.0 * ((n * l_m) * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om))))) / Om)))) elif t_1 <= 1e+255: tmp = math.sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0)))))) else: tmp = math.sqrt((U * ((n * (-2.0 + ((n * U_42_) / Om))) / Om))) * (l_m * math.sqrt(2.0)) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) t_1 = Float64(Float64(U * Float64(2.0 * n)) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l_m * l_m) / Om))) + Float64(Float64(n * (Float64(l_m / Om) ^ 2.0)) * Float64(U_42_ - U)))) tmp = 0.0 if (t_1 <= 0.0) tmp = sqrt(Float64(U * Float64(Float64(2.0 * Float64(n * t)) + Float64(Float64(2.0 * Float64(Float64(n * l_m) * Float64(Float64(l_m * -2.0) + Float64(U_42_ * Float64(Float64(n * l_m) / Om))))) / Om)))); elseif (t_1 <= 1e+255) tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l_m / Om) * Float64(Float64(Float64(U - U_42_) * Float64(n / Float64(Om / l_m))) - Float64(l_m * -2.0)))))); else tmp = Float64(sqrt(Float64(U * Float64(Float64(n * Float64(-2.0 + Float64(Float64(n * U_42_) / Om))) / Om))) * Float64(l_m * sqrt(2.0))); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) t_1 = (U * (2.0 * n)) * ((t - (2.0 * ((l_m * l_m) / Om))) + ((n * ((l_m / Om) ^ 2.0)) * (U_42_ - U))); tmp = 0.0; if (t_1 <= 0.0) tmp = sqrt((U * ((2.0 * (n * t)) + ((2.0 * ((n * l_m) * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om))))) / Om)))); elseif (t_1 <= 1e+255) tmp = sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0)))))); else tmp = sqrt((U * ((n * (-2.0 + ((n * U_42_) / Om))) / Om))) * (l_m * sqrt(2.0)); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision]
code[n_, U_, t_, l$95$m_, Om_, U$42$_] := Block[{t$95$1 = N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l$95$m * l$95$m), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(n * N[Power[N[(l$95$m / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[Sqrt[N[(U * N[(N[(2.0 * N[(n * t), $MachinePrecision]), $MachinePrecision] + N[(N[(2.0 * N[(N[(n * l$95$m), $MachinePrecision] * N[(N[(l$95$m * -2.0), $MachinePrecision] + N[(U$42$ * N[(N[(n * l$95$m), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$1, 1e+255], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l$95$m / Om), $MachinePrecision] * N[(N[(N[(U - U$42$), $MachinePrecision] * N[(n / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(U * N[(N[(n * N[(-2.0 + N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := \left(U \cdot \left(2 \cdot n\right)\right) \cdot \left(\left(t - 2 \cdot \frac{l\_m \cdot l\_m}{Om}\right) + \left(n \cdot {\left(\frac{l\_m}{Om}\right)}^{2}\right) \cdot \left(U* - U\right)\right)\\
\mathbf{if}\;t\_1 \leq 0:\\
\;\;\;\;\sqrt{U \cdot \left(2 \cdot \left(n \cdot t\right) + \frac{2 \cdot \left(\left(n \cdot l\_m\right) \cdot \left(l\_m \cdot -2 + U* \cdot \frac{n \cdot l\_m}{Om}\right)\right)}{Om}\right)}\\
\mathbf{elif}\;t\_1 \leq 10^{+255}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{l\_m}{Om} \cdot \left(\left(U - U*\right) \cdot \frac{n}{\frac{Om}{l\_m}} - l\_m \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \frac{n \cdot \left(-2 + \frac{n \cdot U*}{Om}\right)}{Om}} \cdot \left(l\_m \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) n) U) (-.f64 (-.f64 t (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) #s(literal 2 binary64))) (-.f64 U U*)))) < 0.0Initial program 14.5%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified21.5%
Applied egg-rr32.1%
Taylor expanded in U around 0
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified48.8%
if 0.0 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) n) U) (-.f64 (-.f64 t (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) #s(literal 2 binary64))) (-.f64 U U*)))) < 9.99999999999999988e254Initial program 95.9%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified96.8%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6498.3%
Applied egg-rr98.3%
if 9.99999999999999988e254 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) n) U) (-.f64 (-.f64 t (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) #s(literal 2 binary64))) (-.f64 U U*)))) Initial program 21.3%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified38.6%
Applied egg-rr42.2%
Taylor expanded in l around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
Simplified31.9%
Taylor expanded in U around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6432.0%
Simplified32.0%
Final simplification59.4%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 6.8e-90)
(sqrt (* (* 2.0 n) (* U (+ t (/ (* U* (* n (/ l_m Om))) (/ Om l_m))))))
(if (<= l_m 1.75e+126)
(sqrt
(*
(* 2.0 (* n U))
(+ t (* (/ l_m Om) (* l_m (+ -2.0 (* n (/ (- U* U) Om))))))))
(*
l_m
(sqrt
(* 2.0 (* U (* n (* (/ 1.0 Om) (+ -2.0 (/ n (/ Om (- U* U)))))))))))))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 <= 6.8e-90) {
tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
} else if (l_m <= 1.75e+126) {
tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * (-2.0 + (n * ((U_42_ - U) / Om))))))));
} else {
tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
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 <= 6.8d-90) then
tmp = sqrt(((2.0d0 * n) * (u * (t + ((u_42 * (n * (l_m / om))) / (om / l_m))))))
else if (l_m <= 1.75d+126) then
tmp = sqrt(((2.0d0 * (n * u)) * (t + ((l_m / om) * (l_m * ((-2.0d0) + (n * ((u_42 - u) / om))))))))
else
tmp = l_m * sqrt((2.0d0 * (u * (n * ((1.0d0 / om) * ((-2.0d0) + (n / (om / (u_42 - u)))))))))
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 <= 6.8e-90) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
} else if (l_m <= 1.75e+126) {
tmp = Math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * (-2.0 + (n * ((U_42_ - U) / Om))))))));
} else {
tmp = l_m * Math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 6.8e-90: tmp = math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))) elif l_m <= 1.75e+126: tmp = math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * (-2.0 + (n * ((U_42_ - U) / Om)))))))) else: tmp = l_m * math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 6.8e-90) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(U_42_ * Float64(n * Float64(l_m / Om))) / Float64(Om / l_m)))))); elseif (l_m <= 1.75e+126) tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t + Float64(Float64(l_m / Om) * Float64(l_m * Float64(-2.0 + Float64(n * Float64(Float64(U_42_ - U) / Om)))))))); else tmp = Float64(l_m * sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(Float64(1.0 / Om) * Float64(-2.0 + Float64(n / Float64(Om / Float64(U_42_ - U)))))))))); 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 <= 6.8e-90) tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))); elseif (l_m <= 1.75e+126) tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * (-2.0 + (n * ((U_42_ - U) / Om)))))))); else tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))); 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, 6.8e-90], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(U$42$ * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 1.75e+126], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * N[(-2.0 + N[(n * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(l$95$m * N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(1.0 / Om), $MachinePrecision] * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 6.8 \cdot 10^{-90}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{U* \cdot \left(n \cdot \frac{l\_m}{Om}\right)}{\frac{Om}{l\_m}}\right)\right)}\\
\mathbf{elif}\;l\_m \leq 1.75 \cdot 10^{+126}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t + \frac{l\_m}{Om} \cdot \left(l\_m \cdot \left(-2 + n \cdot \frac{U* - U}{Om}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;l\_m \cdot \sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(\frac{1}{Om} \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 6.79999999999999988e-90Initial program 51.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified58.1%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6459.6%
Applied egg-rr59.6%
Applied egg-rr58.7%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6452.9%
Simplified52.9%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6453.7%
Applied egg-rr53.7%
if 6.79999999999999988e-90 < l < 1.7500000000000001e126Initial program 73.5%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified72.8%
Taylor expanded in n around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
sub-negN/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6475.4%
Simplified75.4%
if 1.7500000000000001e126 < l Initial program 20.2%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified50.0%
Taylor expanded in l around inf
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
Simplified63.7%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr71.7%
Final simplification60.0%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 7.4e-10)
(sqrt (* (* 2.0 n) (* U (+ t (/ (* U* (* n (/ l_m Om))) (/ Om l_m))))))
(if (<= l_m 3.2e+125)
(sqrt (* (* U (* 2.0 n)) (+ t (/ (* (* l_m l_m) -2.0) Om))))
(*
l_m
(sqrt
(* 2.0 (* U (* n (* (/ 1.0 Om) (+ -2.0 (/ n (/ Om (- U* U)))))))))))))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 <= 7.4e-10) {
tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
} else if (l_m <= 3.2e+125) {
tmp = sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om))));
} else {
tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
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 <= 7.4d-10) then
tmp = sqrt(((2.0d0 * n) * (u * (t + ((u_42 * (n * (l_m / om))) / (om / l_m))))))
else if (l_m <= 3.2d+125) then
tmp = sqrt(((u * (2.0d0 * n)) * (t + (((l_m * l_m) * (-2.0d0)) / om))))
else
tmp = l_m * sqrt((2.0d0 * (u * (n * ((1.0d0 / om) * ((-2.0d0) + (n / (om / (u_42 - u)))))))))
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 <= 7.4e-10) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
} else if (l_m <= 3.2e+125) {
tmp = Math.sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om))));
} else {
tmp = l_m * Math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 7.4e-10: tmp = math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))) elif l_m <= 3.2e+125: tmp = math.sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om)))) else: tmp = l_m * math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 7.4e-10) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(U_42_ * Float64(n * Float64(l_m / Om))) / Float64(Om / l_m)))))); elseif (l_m <= 3.2e+125) tmp = sqrt(Float64(Float64(U * Float64(2.0 * n)) * Float64(t + Float64(Float64(Float64(l_m * l_m) * -2.0) / Om)))); else tmp = Float64(l_m * sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(Float64(1.0 / Om) * Float64(-2.0 + Float64(n / Float64(Om / Float64(U_42_ - U)))))))))); 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 <= 7.4e-10) tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))); elseif (l_m <= 3.2e+125) tmp = sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om)))); else tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))); 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, 7.4e-10], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(U$42$ * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 3.2e+125], N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * -2.0), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(l$95$m * N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(1.0 / Om), $MachinePrecision] * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 7.4 \cdot 10^{-10}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{U* \cdot \left(n \cdot \frac{l\_m}{Om}\right)}{\frac{Om}{l\_m}}\right)\right)}\\
\mathbf{elif}\;l\_m \leq 3.2 \cdot 10^{+125}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot \left(t + \frac{\left(l\_m \cdot l\_m\right) \cdot -2}{Om}\right)}\\
\mathbf{else}:\\
\;\;\;\;l\_m \cdot \sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(\frac{1}{Om} \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 7.4000000000000003e-10Initial program 52.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified59.0%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6460.4%
Applied egg-rr60.4%
Applied egg-rr60.6%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6454.2%
Simplified54.2%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6455.0%
Applied egg-rr55.0%
if 7.4000000000000003e-10 < l < 3.19999999999999983e125Initial program 77.5%
Taylor expanded in Om around inf
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6473.8%
Simplified73.8%
if 3.19999999999999983e125 < l Initial program 20.2%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified50.0%
Taylor expanded in l around inf
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
Simplified63.7%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr71.7%
Final simplification59.7%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 3.9e+126)
(sqrt
(*
(* 2.0 (* n U))
(- t (* (/ l_m Om) (- (* (- U U*) (/ n (/ Om l_m))) (* l_m -2.0))))))
(*
l_m
(sqrt (* 2.0 (* U (* n (* (/ 1.0 Om) (+ -2.0 (/ n (/ Om (- U* U))))))))))))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.9e+126) {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0))))));
} else {
tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
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.9d+126) then
tmp = sqrt(((2.0d0 * (n * u)) * (t - ((l_m / om) * (((u - u_42) * (n / (om / l_m))) - (l_m * (-2.0d0)))))))
else
tmp = l_m * sqrt((2.0d0 * (u * (n * ((1.0d0 / om) * ((-2.0d0) + (n / (om / (u_42 - u)))))))))
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.9e+126) {
tmp = Math.sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0))))));
} else {
tmp = l_m * Math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 3.9e+126: tmp = math.sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0)))))) else: tmp = l_m * math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 3.9e+126) tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l_m / Om) * Float64(Float64(Float64(U - U_42_) * Float64(n / Float64(Om / l_m))) - Float64(l_m * -2.0)))))); else tmp = Float64(l_m * sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(Float64(1.0 / Om) * Float64(-2.0 + Float64(n / Float64(Om / Float64(U_42_ - U)))))))))); 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.9e+126) tmp = sqrt(((2.0 * (n * U)) * (t - ((l_m / Om) * (((U - U_42_) * (n / (Om / l_m))) - (l_m * -2.0)))))); else tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))); 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.9e+126], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l$95$m / Om), $MachinePrecision] * N[(N[(N[(U - U$42$), $MachinePrecision] * N[(n / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(l$95$m * N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(1.0 / Om), $MachinePrecision] * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 3.9 \cdot 10^{+126}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{l\_m}{Om} \cdot \left(\left(U - U*\right) \cdot \frac{n}{\frac{Om}{l\_m}} - l\_m \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;l\_m \cdot \sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(\frac{1}{Om} \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 3.89999999999999993e126Initial program 55.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified60.7%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6462.4%
Applied egg-rr62.4%
if 3.89999999999999993e126 < l Initial program 20.2%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified50.0%
Taylor expanded in l around inf
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
Simplified63.7%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr71.7%
Final simplification64.0%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 2.1e-8)
(sqrt (* (* 2.0 n) (* U (+ t (/ (* U* (* n (/ l_m Om))) (/ Om l_m))))))
(if (<= l_m 2.85e+127)
(sqrt (* (* U (* 2.0 n)) (+ t (/ (* (* l_m l_m) -2.0) Om))))
(*
l_m
(sqrt (* 2.0 (/ U (/ Om (* n (+ -2.0 (/ n (/ Om (- U* U)))))))))))))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.1e-8) {
tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
} else if (l_m <= 2.85e+127) {
tmp = sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om))));
} else {
tmp = l_m * sqrt((2.0 * (U / (Om / (n * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
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 <= 2.1d-8) then
tmp = sqrt(((2.0d0 * n) * (u * (t + ((u_42 * (n * (l_m / om))) / (om / l_m))))))
else if (l_m <= 2.85d+127) then
tmp = sqrt(((u * (2.0d0 * n)) * (t + (((l_m * l_m) * (-2.0d0)) / om))))
else
tmp = l_m * sqrt((2.0d0 * (u / (om / (n * ((-2.0d0) + (n / (om / (u_42 - u)))))))))
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 <= 2.1e-8) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
} else if (l_m <= 2.85e+127) {
tmp = Math.sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om))));
} else {
tmp = l_m * Math.sqrt((2.0 * (U / (Om / (n * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 2.1e-8: tmp = math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))) elif l_m <= 2.85e+127: tmp = math.sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om)))) else: tmp = l_m * math.sqrt((2.0 * (U / (Om / (n * (-2.0 + (n / (Om / (U_42_ - U))))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 2.1e-8) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(U_42_ * Float64(n * Float64(l_m / Om))) / Float64(Om / l_m)))))); elseif (l_m <= 2.85e+127) tmp = sqrt(Float64(Float64(U * Float64(2.0 * n)) * Float64(t + Float64(Float64(Float64(l_m * l_m) * -2.0) / Om)))); else tmp = Float64(l_m * sqrt(Float64(2.0 * Float64(U / Float64(Om / Float64(n * Float64(-2.0 + Float64(n / Float64(Om / Float64(U_42_ - U)))))))))); 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 <= 2.1e-8) tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))); elseif (l_m <= 2.85e+127) tmp = sqrt(((U * (2.0 * n)) * (t + (((l_m * l_m) * -2.0) / Om)))); else tmp = l_m * sqrt((2.0 * (U / (Om / (n * (-2.0 + (n / (Om / (U_42_ - U))))))))); 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, 2.1e-8], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(U$42$ * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 2.85e+127], N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * -2.0), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(l$95$m * N[Sqrt[N[(2.0 * N[(U / N[(Om / N[(n * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 2.1 \cdot 10^{-8}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{U* \cdot \left(n \cdot \frac{l\_m}{Om}\right)}{\frac{Om}{l\_m}}\right)\right)}\\
\mathbf{elif}\;l\_m \leq 2.85 \cdot 10^{+127}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot \left(t + \frac{\left(l\_m \cdot l\_m\right) \cdot -2}{Om}\right)}\\
\mathbf{else}:\\
\;\;\;\;l\_m \cdot \sqrt{2 \cdot \frac{U}{\frac{Om}{n \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)}}}\\
\end{array}
\end{array}
if l < 2.09999999999999994e-8Initial program 52.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified59.0%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6460.4%
Applied egg-rr60.4%
Applied egg-rr60.6%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6454.2%
Simplified54.2%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6455.0%
Applied egg-rr55.0%
if 2.09999999999999994e-8 < l < 2.85000000000000021e127Initial program 77.5%
Taylor expanded in Om around inf
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6473.8%
Simplified73.8%
if 2.85000000000000021e127 < l Initial program 20.2%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified50.0%
Applied egg-rr58.7%
Taylor expanded in l around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
Simplified68.8%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr67.9%
Final simplification59.0%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= U* -3.2e+103)
(sqrt (* (* 2.0 n) (* U (+ t (/ (* U* (/ n (/ Om l_m))) (/ Om l_m))))))
(if (<= U* 8.2e-54)
(sqrt (* (* 2.0 (* n U)) (+ t (* (/ l_m Om) (* l_m -2.0)))))
(sqrt (* (* 2.0 n) (* U (+ t (/ (* U* (* n (/ l_m Om))) (/ Om l_m)))))))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (U_42_ <= -3.2e+103) {
tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n / (Om / l_m))) / (Om / l_m))))));
} else if (U_42_ <= 8.2e-54) {
tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
} else {
tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
}
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_42 <= (-3.2d+103)) then
tmp = sqrt(((2.0d0 * n) * (u * (t + ((u_42 * (n / (om / l_m))) / (om / l_m))))))
else if (u_42 <= 8.2d-54) then
tmp = sqrt(((2.0d0 * (n * u)) * (t + ((l_m / om) * (l_m * (-2.0d0))))))
else
tmp = sqrt(((2.0d0 * n) * (u * (t + ((u_42 * (n * (l_m / om))) / (om / l_m))))))
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_42_ <= -3.2e+103) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n / (Om / l_m))) / (Om / l_m))))));
} else if (U_42_ <= 8.2e-54) {
tmp = Math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
} else {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U_42_ <= -3.2e+103: tmp = math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n / (Om / l_m))) / (Om / l_m)))))) elif U_42_ <= 8.2e-54: tmp = math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0))))) else: tmp = math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U_42_ <= -3.2e+103) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(U_42_ * Float64(n / Float64(Om / l_m))) / Float64(Om / l_m)))))); elseif (U_42_ <= 8.2e-54) tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t + Float64(Float64(l_m / Om) * Float64(l_m * -2.0))))); else tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(U_42_ * Float64(n * Float64(l_m / Om))) / Float64(Om / l_m)))))); 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_42_ <= -3.2e+103) tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n / (Om / l_m))) / (Om / l_m)))))); elseif (U_42_ <= 8.2e-54) tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0))))); else tmp = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[U$42$, -3.2e+103], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(U$42$ * N[(n / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[U$42$, 8.2e-54], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(U$42$ * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U* \leq -3.2 \cdot 10^{+103}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{U* \cdot \frac{n}{\frac{Om}{l\_m}}}{\frac{Om}{l\_m}}\right)\right)}\\
\mathbf{elif}\;U* \leq 8.2 \cdot 10^{-54}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t + \frac{l\_m}{Om} \cdot \left(l\_m \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{U* \cdot \left(n \cdot \frac{l\_m}{Om}\right)}{\frac{Om}{l\_m}}\right)\right)}\\
\end{array}
\end{array}
if U* < -3.19999999999999993e103Initial program 46.4%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified57.6%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6461.9%
Applied egg-rr61.9%
Applied egg-rr62.9%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6459.7%
Simplified59.7%
*-commutativeN/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6464.0%
Applied egg-rr64.0%
if -3.19999999999999993e103 < U* < 8.2000000000000001e-54Initial program 50.5%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified59.6%
Taylor expanded in n around 0
*-lowering-*.f6459.4%
Simplified59.4%
if 8.2000000000000001e-54 < U* Initial program 49.0%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified58.7%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6458.7%
Applied egg-rr58.7%
Applied egg-rr61.3%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6456.3%
Simplified56.3%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6456.3%
Applied egg-rr56.3%
Final simplification59.4%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(let* ((t_1
(sqrt
(* (* 2.0 n) (* U (+ t (/ (* U* (* n (/ l_m Om))) (/ Om l_m))))))))
(if (<= U* -1.05e+103)
t_1
(if (<= U* 2.6e-53)
(sqrt (* (* 2.0 (* n U)) (+ t (* (/ l_m Om) (* l_m -2.0)))))
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(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
double tmp;
if (U_42_ <= -1.05e+103) {
tmp = t_1;
} else if (U_42_ <= 2.6e-53) {
tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
} else {
tmp = t_1;
}
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) :: t_1
real(8) :: tmp
t_1 = sqrt(((2.0d0 * n) * (u * (t + ((u_42 * (n * (l_m / om))) / (om / l_m))))))
if (u_42 <= (-1.05d+103)) then
tmp = t_1
else if (u_42 <= 2.6d-53) then
tmp = sqrt(((2.0d0 * (n * u)) * (t + ((l_m / om) * (l_m * (-2.0d0))))))
else
tmp = t_1
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 t_1 = Math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m))))));
double tmp;
if (U_42_ <= -1.05e+103) {
tmp = t_1;
} else if (U_42_ <= 2.6e-53) {
tmp = Math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
} else {
tmp = t_1;
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): t_1 = math.sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))) tmp = 0 if U_42_ <= -1.05e+103: tmp = t_1 elif U_42_ <= 2.6e-53: tmp = math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0))))) else: tmp = t_1 return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) t_1 = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(U_42_ * Float64(n * Float64(l_m / Om))) / Float64(Om / l_m)))))) tmp = 0.0 if (U_42_ <= -1.05e+103) tmp = t_1; elseif (U_42_ <= 2.6e-53) tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t + Float64(Float64(l_m / Om) * Float64(l_m * -2.0))))); else tmp = t_1; end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) t_1 = sqrt(((2.0 * n) * (U * (t + ((U_42_ * (n * (l_m / Om))) / (Om / l_m)))))); tmp = 0.0; if (U_42_ <= -1.05e+103) tmp = t_1; elseif (U_42_ <= 2.6e-53) tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0))))); else tmp = t_1; end tmp_2 = 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[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(U$42$ * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[U$42$, -1.05e+103], t$95$1, If[LessEqual[U$42$, 2.6e-53], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := \sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{U* \cdot \left(n \cdot \frac{l\_m}{Om}\right)}{\frac{Om}{l\_m}}\right)\right)}\\
\mathbf{if}\;U* \leq -1.05 \cdot 10^{+103}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;U* \leq 2.6 \cdot 10^{-53}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t + \frac{l\_m}{Om} \cdot \left(l\_m \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if U* < -1.0500000000000001e103 or 2.59999999999999996e-53 < U* Initial program 48.0%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified58.3%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6460.0%
Applied egg-rr60.0%
Applied egg-rr61.9%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6457.7%
Simplified57.7%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6459.4%
Applied egg-rr59.4%
if -1.0500000000000001e103 < U* < 2.59999999999999996e-53Initial program 50.5%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified59.6%
Taylor expanded in n around 0
*-lowering-*.f6459.4%
Simplified59.4%
Final simplification59.4%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(let* ((t_1
(sqrt
(* (* 2.0 (* n U)) (+ t (* (/ l_m Om) (* U* (/ (* n l_m) Om))))))))
(if (<= U* -19000000000.0)
t_1
(if (<= U* 1.45e+111)
(sqrt (* (* 2.0 n) (* U (+ t (/ (* l_m -2.0) (/ Om l_m))))))
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(((2.0 * (n * U)) * (t + ((l_m / Om) * (U_42_ * ((n * l_m) / Om))))));
double tmp;
if (U_42_ <= -19000000000.0) {
tmp = t_1;
} else if (U_42_ <= 1.45e+111) {
tmp = sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m))))));
} else {
tmp = t_1;
}
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) :: t_1
real(8) :: tmp
t_1 = sqrt(((2.0d0 * (n * u)) * (t + ((l_m / om) * (u_42 * ((n * l_m) / om))))))
if (u_42 <= (-19000000000.0d0)) then
tmp = t_1
else if (u_42 <= 1.45d+111) then
tmp = sqrt(((2.0d0 * n) * (u * (t + ((l_m * (-2.0d0)) / (om / l_m))))))
else
tmp = t_1
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 t_1 = Math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (U_42_ * ((n * l_m) / Om))))));
double tmp;
if (U_42_ <= -19000000000.0) {
tmp = t_1;
} else if (U_42_ <= 1.45e+111) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m))))));
} else {
tmp = t_1;
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): t_1 = math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (U_42_ * ((n * l_m) / Om)))))) tmp = 0 if U_42_ <= -19000000000.0: tmp = t_1 elif U_42_ <= 1.45e+111: tmp = math.sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m)))))) else: tmp = t_1 return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) t_1 = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t + Float64(Float64(l_m / Om) * Float64(U_42_ * Float64(Float64(n * l_m) / Om)))))) tmp = 0.0 if (U_42_ <= -19000000000.0) tmp = t_1; elseif (U_42_ <= 1.45e+111) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l_m * -2.0) / Float64(Om / l_m)))))); else tmp = t_1; end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) t_1 = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (U_42_ * ((n * l_m) / Om)))))); tmp = 0.0; if (U_42_ <= -19000000000.0) tmp = t_1; elseif (U_42_ <= 1.45e+111) tmp = sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m)))))); else tmp = t_1; end tmp_2 = 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[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(l$95$m / Om), $MachinePrecision] * N[(U$42$ * N[(N[(n * l$95$m), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[U$42$, -19000000000.0], t$95$1, If[LessEqual[U$42$, 1.45e+111], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l$95$m * -2.0), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := \sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t + \frac{l\_m}{Om} \cdot \left(U* \cdot \frac{n \cdot l\_m}{Om}\right)\right)}\\
\mathbf{if}\;U* \leq -19000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;U* \leq 1.45 \cdot 10^{+111}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{l\_m \cdot -2}{\frac{Om}{l\_m}}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if U* < -1.9e10 or 1.45e111 < U* Initial program 46.7%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified59.4%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6457.9%
Simplified57.9%
if -1.9e10 < U* < 1.45e111Initial program 51.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified58.5%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6460.0%
Applied egg-rr60.0%
Applied egg-rr61.3%
Taylor expanded in Om around inf
*-lowering-*.f6457.8%
Simplified57.8%
Final simplification57.8%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 3.6e+126)
(sqrt
(*
(* 2.0 n)
(* U (+ t (/ (* l_m (+ (* l_m -2.0) (* U* (/ (* n l_m) Om)))) Om)))))
(*
l_m
(sqrt (* 2.0 (* U (* n (* (/ 1.0 Om) (+ -2.0 (/ n (/ Om (- U* U))))))))))))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+126) {
tmp = sqrt(((2.0 * n) * (U * (t + ((l_m * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om)))) / Om)))));
} else {
tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
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+126) then
tmp = sqrt(((2.0d0 * n) * (u * (t + ((l_m * ((l_m * (-2.0d0)) + (u_42 * ((n * l_m) / om)))) / om)))))
else
tmp = l_m * sqrt((2.0d0 * (u * (n * ((1.0d0 / om) * ((-2.0d0) + (n / (om / (u_42 - u)))))))))
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+126) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((l_m * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om)))) / Om)))));
} else {
tmp = l_m * Math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U)))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 3.6e+126: tmp = math.sqrt(((2.0 * n) * (U * (t + ((l_m * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om)))) / Om))))) else: tmp = l_m * math.sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 3.6e+126) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l_m * Float64(Float64(l_m * -2.0) + Float64(U_42_ * Float64(Float64(n * l_m) / Om)))) / Om))))); else tmp = Float64(l_m * sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(Float64(1.0 / Om) * Float64(-2.0 + Float64(n / Float64(Om / Float64(U_42_ - U)))))))))); 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+126) tmp = sqrt(((2.0 * n) * (U * (t + ((l_m * ((l_m * -2.0) + (U_42_ * ((n * l_m) / Om)))) / Om))))); else tmp = l_m * sqrt((2.0 * (U * (n * ((1.0 / Om) * (-2.0 + (n / (Om / (U_42_ - U))))))))); 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+126], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l$95$m * N[(N[(l$95$m * -2.0), $MachinePrecision] + N[(U$42$ * N[(N[(n * l$95$m), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(l$95$m * N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(1.0 / Om), $MachinePrecision] * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 3.6 \cdot 10^{+126}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{l\_m \cdot \left(l\_m \cdot -2 + U* \cdot \frac{n \cdot l\_m}{Om}\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;l\_m \cdot \sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(\frac{1}{Om} \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 3.6e126Initial program 55.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified60.7%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6462.4%
Applied egg-rr62.4%
Applied egg-rr61.2%
Taylor expanded in U around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6458.1%
Simplified58.1%
if 3.6e126 < l Initial program 20.2%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified50.0%
Taylor expanded in l around inf
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
Simplified63.7%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr71.7%
Final simplification60.4%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U -1.5e-143) (sqrt (* (* 2.0 (* n U)) (+ t (* (/ l_m Om) (* l_m -2.0))))) (sqrt (* (* 2.0 n) (* U (+ t (/ (* l_m -2.0) (/ Om l_m))))))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (U <= -1.5e-143) {
tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
} else {
tmp = sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m))))));
}
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 <= (-1.5d-143)) then
tmp = sqrt(((2.0d0 * (n * u)) * (t + ((l_m / om) * (l_m * (-2.0d0))))))
else
tmp = sqrt(((2.0d0 * n) * (u * (t + ((l_m * (-2.0d0)) / (om / l_m))))))
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 <= -1.5e-143) {
tmp = Math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
} else {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U <= -1.5e-143: tmp = math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0))))) else: tmp = math.sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m)))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U <= -1.5e-143) tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t + Float64(Float64(l_m / Om) * Float64(l_m * -2.0))))); else tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l_m * -2.0) / Float64(Om / l_m)))))); 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 <= -1.5e-143) tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0))))); else tmp = sqrt(((2.0 * n) * (U * (t + ((l_m * -2.0) / (Om / l_m)))))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[U, -1.5e-143], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l$95$m * -2.0), $MachinePrecision] / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U \leq -1.5 \cdot 10^{-143}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t + \frac{l\_m}{Om} \cdot \left(l\_m \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{l\_m \cdot -2}{\frac{Om}{l\_m}}\right)\right)}\\
\end{array}
\end{array}
if U < -1.49999999999999993e-143Initial program 53.6%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified65.7%
Taylor expanded in n around 0
*-lowering-*.f6454.7%
Simplified54.7%
if -1.49999999999999993e-143 < U Initial program 46.7%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified55.3%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6456.5%
Applied egg-rr56.5%
Applied egg-rr61.4%
Taylor expanded in Om around inf
*-lowering-*.f6450.0%
Simplified50.0%
Final simplification51.7%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (sqrt (* (* 2.0 (* n U)) (+ t (* (/ l_m Om) (* l_m -2.0))))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
return sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
}
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(((2.0d0 * (n * u)) * (t + ((l_m / om) * (l_m * (-2.0d0))))))
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(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))));
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): return math.sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0)))))
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) return sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t + Float64(Float64(l_m / Om) * Float64(l_m * -2.0))))) end
l_m = abs(l); function tmp = code(n, U, t, l_m, Om, U_42_) tmp = sqrt(((2.0 * (n * U)) * (t + ((l_m / Om) * (l_m * -2.0))))); end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t + N[(N[(l$95$m / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t + \frac{l\_m}{Om} \cdot \left(l\_m \cdot -2\right)\right)}
\end{array}
Initial program 49.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified58.9%
Taylor expanded in n around 0
*-lowering-*.f6448.1%
Simplified48.1%
Final simplification48.1%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U -5e-269) (pow (* U (* n (* 2.0 t))) 0.5) (sqrt (* 2.0 (* n (* U 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 <= -5e-269) {
tmp = pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = sqrt((2.0 * (n * (U * 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 <= (-5d-269)) then
tmp = (u * (n * (2.0d0 * t))) ** 0.5d0
else
tmp = sqrt((2.0d0 * (n * (u * 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 <= -5e-269) {
tmp = Math.pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = Math.sqrt((2.0 * (n * (U * t))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U <= -5e-269: tmp = math.pow((U * (n * (2.0 * t))), 0.5) else: tmp = math.sqrt((2.0 * (n * (U * t)))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U <= -5e-269) tmp = Float64(U * Float64(n * Float64(2.0 * t))) ^ 0.5; else tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * 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 <= -5e-269) tmp = (U * (n * (2.0 * t))) ^ 0.5; else tmp = sqrt((2.0 * (n * (U * 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, -5e-269], N[Power[N[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U \leq -5 \cdot 10^{-269}:\\
\;\;\;\;{\left(U \cdot \left(n \cdot \left(2 \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot t\right)\right)}\\
\end{array}
\end{array}
if U < -4.99999999999999979e-269Initial program 49.3%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified60.2%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6439.3%
Simplified39.3%
pow1/2N/A
*-commutativeN/A
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6441.7%
Applied egg-rr41.7%
if -4.99999999999999979e-269 < U Initial program 48.9%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified57.6%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6427.1%
Simplified27.1%
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6435.0%
Applied egg-rr35.0%
Final simplification38.3%
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 * Float64(2.0 * 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 * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot t}
\end{array}
Initial program 49.1%
Taylor expanded in t around inf
Simplified36.4%
Final simplification36.4%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (sqrt (* 2.0 (* t (* n U)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
return sqrt((2.0 * (t * (n * U))));
}
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((2.0d0 * (t * (n * u))))
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((2.0 * (t * (n * U))));
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): return math.sqrt((2.0 * (t * (n * U))))
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) return sqrt(Float64(2.0 * Float64(t * Float64(n * U)))) end
l_m = abs(l); function tmp = code(n, U, t, l_m, Om, U_42_) tmp = sqrt((2.0 * (t * (n * U)))); end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := N[Sqrt[N[(2.0 * N[(t * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\sqrt{2 \cdot \left(t \cdot \left(n \cdot U\right)\right)}
\end{array}
Initial program 49.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified58.9%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6433.1%
Simplified33.1%
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6436.3%
Applied egg-rr36.3%
Final simplification36.3%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (sqrt (* 2.0 (* U (* n t)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
return sqrt((2.0 * (U * (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((2.0d0 * (u * (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((2.0 * (U * (n * t))));
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): return math.sqrt((2.0 * (U * (n * t))))
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) return sqrt(Float64(2.0 * Float64(U * Float64(n * t)))) end
l_m = abs(l); function tmp = code(n, U, t, l_m, Om, U_42_) tmp = sqrt((2.0 * (U * (n * t)))); end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := N[Sqrt[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\sqrt{2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}
\end{array}
Initial program 49.1%
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
+-commutativeN/A
Simplified58.9%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6433.1%
Simplified33.1%
herbie shell --seed 2024164
(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*))))))