
(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 20 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 (* (* n (pow (/ l_m Om) 2.0)) (- U* U)))
(t_2 (* U (* 2.0 n)))
(t_3 (sqrt (* t_2 (+ (- t (* 2.0 (/ (* l_m l_m) Om))) t_1)))))
(if (<= t_3 0.0)
(*
(sqrt
(*
(* 2.0 n)
(+ t (/ (- -2.0 (/ (* n (- U U*)) Om)) (/ Om (* l_m l_m))))))
(sqrt U))
(if (<= t_3 INFINITY)
(sqrt (* t_2 (+ (- t (* 2.0 (/ l_m (/ Om l_m)))) t_1)))
(*
(* l_m (sqrt 2.0))
(sqrt
(* n (+ (* -2.0 (/ U Om)) (/ (* U (* n (- U* U))) (* Om Om))))))))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double t_1 = (n * pow((l_m / Om), 2.0)) * (U_42_ - U);
double t_2 = U * (2.0 * n);
double t_3 = sqrt((t_2 * ((t - (2.0 * ((l_m * l_m) / Om))) + t_1)));
double tmp;
if (t_3 <= 0.0) {
tmp = sqrt(((2.0 * n) * (t + ((-2.0 - ((n * (U - U_42_)) / Om)) / (Om / (l_m * l_m)))))) * sqrt(U);
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt((t_2 * ((t - (2.0 * (l_m / (Om / l_m)))) + t_1)));
} else {
tmp = (l_m * sqrt(2.0)) * sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * Om)))));
}
return tmp;
}
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 = (n * Math.pow((l_m / Om), 2.0)) * (U_42_ - U);
double t_2 = U * (2.0 * n);
double t_3 = Math.sqrt((t_2 * ((t - (2.0 * ((l_m * l_m) / Om))) + t_1)));
double tmp;
if (t_3 <= 0.0) {
tmp = Math.sqrt(((2.0 * n) * (t + ((-2.0 - ((n * (U - U_42_)) / Om)) / (Om / (l_m * l_m)))))) * Math.sqrt(U);
} else if (t_3 <= Double.POSITIVE_INFINITY) {
tmp = Math.sqrt((t_2 * ((t - (2.0 * (l_m / (Om / l_m)))) + t_1)));
} else {
tmp = (l_m * Math.sqrt(2.0)) * Math.sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * Om)))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): t_1 = (n * math.pow((l_m / Om), 2.0)) * (U_42_ - U) t_2 = U * (2.0 * n) t_3 = math.sqrt((t_2 * ((t - (2.0 * ((l_m * l_m) / Om))) + t_1))) tmp = 0 if t_3 <= 0.0: tmp = math.sqrt(((2.0 * n) * (t + ((-2.0 - ((n * (U - U_42_)) / Om)) / (Om / (l_m * l_m)))))) * math.sqrt(U) elif t_3 <= math.inf: tmp = math.sqrt((t_2 * ((t - (2.0 * (l_m / (Om / l_m)))) + t_1))) else: tmp = (l_m * math.sqrt(2.0)) * math.sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * Om))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) t_1 = Float64(Float64(n * (Float64(l_m / Om) ^ 2.0)) * Float64(U_42_ - U)) t_2 = Float64(U * Float64(2.0 * n)) t_3 = sqrt(Float64(t_2 * Float64(Float64(t - Float64(2.0 * Float64(Float64(l_m * l_m) / Om))) + t_1))) tmp = 0.0 if (t_3 <= 0.0) tmp = Float64(sqrt(Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(-2.0 - Float64(Float64(n * Float64(U - U_42_)) / Om)) / Float64(Om / Float64(l_m * l_m)))))) * sqrt(U)); elseif (t_3 <= Inf) tmp = sqrt(Float64(t_2 * Float64(Float64(t - Float64(2.0 * Float64(l_m / Float64(Om / l_m)))) + t_1))); else tmp = Float64(Float64(l_m * sqrt(2.0)) * sqrt(Float64(n * Float64(Float64(-2.0 * Float64(U / Om)) + Float64(Float64(U * Float64(n * Float64(U_42_ - U))) / Float64(Om * Om)))))); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) t_1 = (n * ((l_m / Om) ^ 2.0)) * (U_42_ - U); t_2 = U * (2.0 * n); t_3 = sqrt((t_2 * ((t - (2.0 * ((l_m * l_m) / Om))) + t_1))); tmp = 0.0; if (t_3 <= 0.0) tmp = sqrt(((2.0 * n) * (t + ((-2.0 - ((n * (U - U_42_)) / Om)) / (Om / (l_m * l_m)))))) * sqrt(U); elseif (t_3 <= Inf) tmp = sqrt((t_2 * ((t - (2.0 * (l_m / (Om / l_m)))) + t_1))); else tmp = (l_m * sqrt(2.0)) * sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * Om))))); 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[(n * N[Power[N[(l$95$m / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(t$95$2 * N[(N[(t - N[(2.0 * N[(N[(l$95$m * l$95$m), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$3, 0.0], N[(N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(-2.0 - N[(N[(n * N[(U - U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[U], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[Sqrt[N[(t$95$2 * N[(N[(t - N[(2.0 * N[(l$95$m / N[(Om / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(n * N[(N[(-2.0 * N[(U / Om), $MachinePrecision]), $MachinePrecision] + N[(N[(U * N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := \left(n \cdot {\left(\frac{l\_m}{Om}\right)}^{2}\right) \cdot \left(U* - U\right)\\
t_2 := U \cdot \left(2 \cdot n\right)\\
t_3 := \sqrt{t\_2 \cdot \left(\left(t - 2 \cdot \frac{l\_m \cdot l\_m}{Om}\right) + t\_1\right)}\\
\mathbf{if}\;t\_3 \leq 0:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(t + \frac{-2 - \frac{n \cdot \left(U - U*\right)}{Om}}{\frac{Om}{l\_m \cdot l\_m}}\right)} \cdot \sqrt{U}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\sqrt{t\_2 \cdot \left(\left(t - 2 \cdot \frac{l\_m}{\frac{Om}{l\_m}}\right) + t\_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot \sqrt{2}\right) \cdot \sqrt{n \cdot \left(-2 \cdot \frac{U}{Om} + \frac{U \cdot \left(n \cdot \left(U* - U\right)\right)}{Om \cdot Om}\right)}\\
\end{array}
\end{array}
if (sqrt.f64 (*.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 20.0%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified41.6%
associate-*r*N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr55.3%
if 0.0 < (sqrt.f64 (*.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*))))) < +inf.0Initial program 70.7%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6475.1%
Applied egg-rr75.1%
if +inf.0 < (sqrt.f64 (*.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 0.0%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified33.6%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6438.2%
Applied egg-rr38.2%
Taylor expanded in n around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified11.9%
Taylor expanded in l around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6427.2%
Simplified27.2%
Final simplification64.1%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 2.5e-184)
(sqrt
(* (+ t (* (* (/ l_m Om) (* n (/ l_m Om))) (- U* U))) (* n (* 2.0 U))))
(if (<= l_m 3.4e+33)
(sqrt
(* (* 2.0 U) (* n (+ t (/ (* (* l_m l_m) (- (* U* (/ n Om)) 2.0)) Om)))))
(if (<= l_m 1.02e+239)
(sqrt
(*
n
(*
2.0
(+
(* (* (/ l_m Om) (+ -2.0 (/ n (/ Om (- U* U))))) (* U l_m))
(* U t)))))
(*
(* l_m (sqrt 2.0))
(sqrt
(* n (+ (* -2.0 (/ U Om)) (/ (* U (* n (- U* U))) (* Om 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.5e-184) {
tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else if (l_m <= 3.4e+33) {
tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om)))));
} else if (l_m <= 1.02e+239) {
tmp = sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (U * t)))));
} else {
tmp = (l_m * sqrt(2.0)) * sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * 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 <= 2.5d-184) then
tmp = sqrt(((t + (((l_m / om) * (n * (l_m / om))) * (u_42 - u))) * (n * (2.0d0 * u))))
else if (l_m <= 3.4d+33) then
tmp = sqrt(((2.0d0 * u) * (n * (t + (((l_m * l_m) * ((u_42 * (n / om)) - 2.0d0)) / om)))))
else if (l_m <= 1.02d+239) then
tmp = sqrt((n * (2.0d0 * ((((l_m / om) * ((-2.0d0) + (n / (om / (u_42 - u))))) * (u * l_m)) + (u * t)))))
else
tmp = (l_m * sqrt(2.0d0)) * sqrt((n * (((-2.0d0) * (u / om)) + ((u * (n * (u_42 - u))) / (om * 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 <= 2.5e-184) {
tmp = Math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else if (l_m <= 3.4e+33) {
tmp = Math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om)))));
} else if (l_m <= 1.02e+239) {
tmp = Math.sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (U * t)))));
} else {
tmp = (l_m * Math.sqrt(2.0)) * Math.sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * Om)))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 2.5e-184: tmp = math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))) elif l_m <= 3.4e+33: tmp = math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))) elif l_m <= 1.02e+239: tmp = math.sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (U * t))))) else: tmp = (l_m * math.sqrt(2.0)) * math.sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * Om))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 2.5e-184) tmp = sqrt(Float64(Float64(t + Float64(Float64(Float64(l_m / Om) * Float64(n * Float64(l_m / Om))) * Float64(U_42_ - U))) * Float64(n * Float64(2.0 * U)))); elseif (l_m <= 3.4e+33) tmp = sqrt(Float64(Float64(2.0 * U) * Float64(n * Float64(t + Float64(Float64(Float64(l_m * l_m) * Float64(Float64(U_42_ * Float64(n / Om)) - 2.0)) / Om))))); elseif (l_m <= 1.02e+239) tmp = sqrt(Float64(n * Float64(2.0 * Float64(Float64(Float64(Float64(l_m / Om) * Float64(-2.0 + Float64(n / Float64(Om / Float64(U_42_ - U))))) * Float64(U * l_m)) + Float64(U * t))))); else tmp = Float64(Float64(l_m * sqrt(2.0)) * sqrt(Float64(n * Float64(Float64(-2.0 * Float64(U / Om)) + Float64(Float64(U * Float64(n * Float64(U_42_ - U))) / Float64(Om * 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 <= 2.5e-184) tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))); elseif (l_m <= 3.4e+33) tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))); elseif (l_m <= 1.02e+239) tmp = sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (U * t))))); else tmp = (l_m * sqrt(2.0)) * sqrt((n * ((-2.0 * (U / Om)) + ((U * (n * (U_42_ - U))) / (Om * 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, 2.5e-184], N[Sqrt[N[(N[(t + N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(n * N[(2.0 * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 3.4e+33], N[Sqrt[N[(N[(2.0 * U), $MachinePrecision] * N[(n * N[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(N[(U$42$ * N[(n / Om), $MachinePrecision]), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 1.02e+239], N[Sqrt[N[(n * N[(2.0 * N[(N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U * l$95$m), $MachinePrecision]), $MachinePrecision] + N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(n * N[(N[(-2.0 * N[(U / Om), $MachinePrecision]), $MachinePrecision] + N[(N[(U * N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 2.5 \cdot 10^{-184}:\\
\;\;\;\;\sqrt{\left(t + \left(\frac{l\_m}{Om} \cdot \left(n \cdot \frac{l\_m}{Om}\right)\right) \cdot \left(U* - U\right)\right) \cdot \left(n \cdot \left(2 \cdot U\right)\right)}\\
\mathbf{elif}\;l\_m \leq 3.4 \cdot 10^{+33}:\\
\;\;\;\;\sqrt{\left(2 \cdot U\right) \cdot \left(n \cdot \left(t + \frac{\left(l\_m \cdot l\_m\right) \cdot \left(U* \cdot \frac{n}{Om} - 2\right)}{Om}\right)\right)}\\
\mathbf{elif}\;l\_m \leq 1.02 \cdot 10^{+239}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(\left(\frac{l\_m}{Om} \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)\right) \cdot \left(U \cdot l\_m\right) + U \cdot t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot \sqrt{2}\right) \cdot \sqrt{n \cdot \left(-2 \cdot \frac{U}{Om} + \frac{U \cdot \left(n \cdot \left(U* - U\right)\right)}{Om \cdot Om}\right)}\\
\end{array}
\end{array}
if l < 2.50000000000000001e-184Initial program 54.3%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr55.3%
Taylor expanded in t around inf
Simplified54.8%
if 2.50000000000000001e-184 < l < 3.3999999999999999e33Initial program 51.6%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified51.3%
Taylor expanded in U around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified55.5%
if 3.3999999999999999e33 < l < 1.02e239Initial program 52.1%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified64.8%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6476.8%
Applied egg-rr76.8%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6476.8%
Applied egg-rr76.8%
+-commutativeN/A
distribute-lft-inN/A
+-lowering-+.f64N/A
Applied egg-rr85.4%
if 1.02e239 < l Initial program 23.1%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified65.0%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6465.0%
Applied egg-rr65.0%
Taylor expanded in n around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified24.9%
Taylor expanded in l around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6478.6%
Simplified78.6%
Final simplification60.1%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 2.65e-184)
(sqrt
(* (+ t (* (* (/ l_m Om) (* n (/ l_m Om))) (- U* U))) (* n (* 2.0 U))))
(if (<= l_m 6.8e+33)
(sqrt
(* (* 2.0 U) (* n (+ t (/ (* (* l_m l_m) (- (* U* (/ n Om)) 2.0)) Om)))))
(sqrt
(*
n
(*
2.0
(+
(* (* (/ l_m Om) (+ -2.0 (/ n (/ Om (- U* U))))) (* U l_m))
(* 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 (l_m <= 2.65e-184) {
tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else if (l_m <= 6.8e+33) {
tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om)))));
} else {
tmp = sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (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 (l_m <= 2.65d-184) then
tmp = sqrt(((t + (((l_m / om) * (n * (l_m / om))) * (u_42 - u))) * (n * (2.0d0 * u))))
else if (l_m <= 6.8d+33) then
tmp = sqrt(((2.0d0 * u) * (n * (t + (((l_m * l_m) * ((u_42 * (n / om)) - 2.0d0)) / om)))))
else
tmp = sqrt((n * (2.0d0 * ((((l_m / om) * ((-2.0d0) + (n / (om / (u_42 - u))))) * (u * l_m)) + (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 (l_m <= 2.65e-184) {
tmp = Math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else if (l_m <= 6.8e+33) {
tmp = Math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om)))));
} else {
tmp = Math.sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (U * t)))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 2.65e-184: tmp = math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))) elif l_m <= 6.8e+33: tmp = math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))) else: tmp = math.sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (U * t))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 2.65e-184) tmp = sqrt(Float64(Float64(t + Float64(Float64(Float64(l_m / Om) * Float64(n * Float64(l_m / Om))) * Float64(U_42_ - U))) * Float64(n * Float64(2.0 * U)))); elseif (l_m <= 6.8e+33) tmp = sqrt(Float64(Float64(2.0 * U) * Float64(n * Float64(t + Float64(Float64(Float64(l_m * l_m) * Float64(Float64(U_42_ * Float64(n / Om)) - 2.0)) / Om))))); else tmp = sqrt(Float64(n * Float64(2.0 * Float64(Float64(Float64(Float64(l_m / Om) * Float64(-2.0 + Float64(n / Float64(Om / Float64(U_42_ - U))))) * Float64(U * l_m)) + 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 (l_m <= 2.65e-184) tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))); elseif (l_m <= 6.8e+33) tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))); else tmp = sqrt((n * (2.0 * ((((l_m / Om) * (-2.0 + (n / (Om / (U_42_ - U))))) * (U * l_m)) + (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[l$95$m, 2.65e-184], N[Sqrt[N[(N[(t + N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(n * N[(2.0 * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l$95$m, 6.8e+33], N[Sqrt[N[(N[(2.0 * U), $MachinePrecision] * N[(n * N[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(N[(U$42$ * N[(n / Om), $MachinePrecision]), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(2.0 * N[(N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U * l$95$m), $MachinePrecision]), $MachinePrecision] + N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 2.65 \cdot 10^{-184}:\\
\;\;\;\;\sqrt{\left(t + \left(\frac{l\_m}{Om} \cdot \left(n \cdot \frac{l\_m}{Om}\right)\right) \cdot \left(U* - U\right)\right) \cdot \left(n \cdot \left(2 \cdot U\right)\right)}\\
\mathbf{elif}\;l\_m \leq 6.8 \cdot 10^{+33}:\\
\;\;\;\;\sqrt{\left(2 \cdot U\right) \cdot \left(n \cdot \left(t + \frac{\left(l\_m \cdot l\_m\right) \cdot \left(U* \cdot \frac{n}{Om} - 2\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(\left(\frac{l\_m}{Om} \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)\right) \cdot \left(U \cdot l\_m\right) + U \cdot t\right)\right)}\\
\end{array}
\end{array}
if l < 2.6500000000000002e-184Initial program 54.3%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr55.3%
Taylor expanded in t around inf
Simplified54.8%
if 2.6500000000000002e-184 < l < 6.7999999999999999e33Initial program 51.6%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified51.3%
Taylor expanded in U around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified55.5%
if 6.7999999999999999e33 < l Initial program 43.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified64.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6473.5%
Applied egg-rr73.5%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6473.5%
Applied egg-rr73.5%
+-commutativeN/A
distribute-lft-inN/A
+-lowering-+.f64N/A
Applied egg-rr77.4%
Final simplification59.0%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(let* ((t_1
(sqrt (* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 Om) (* l_m -2.0))))))))))
(if (<= Om -9.5e-123)
t_1
(if (<= Om 4e-308)
(sqrt (* n (/ (/ (* 2.0 (* U (* U* (* n (* l_m l_m))))) Om) Om)))
(if (<= Om 6.6e-81)
(/ (sqrt (* (* n -2.0) (* (- U U*) (* (* l_m l_m) (* n U))))) 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((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
double tmp;
if (Om <= -9.5e-123) {
tmp = t_1;
} else if (Om <= 4e-308) {
tmp = sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / Om)));
} else if (Om <= 6.6e-81) {
tmp = sqrt(((n * -2.0) * ((U - U_42_) * ((l_m * l_m) * (n * U))))) / Om;
} 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((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (l_m * (-2.0d0)))))))))
if (om <= (-9.5d-123)) then
tmp = t_1
else if (om <= 4d-308) then
tmp = sqrt((n * (((2.0d0 * (u * (u_42 * (n * (l_m * l_m))))) / om) / om)))
else if (om <= 6.6d-81) then
tmp = sqrt(((n * (-2.0d0)) * ((u - u_42) * ((l_m * l_m) * (n * u))))) / om
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((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
double tmp;
if (Om <= -9.5e-123) {
tmp = t_1;
} else if (Om <= 4e-308) {
tmp = Math.sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / Om)));
} else if (Om <= 6.6e-81) {
tmp = Math.sqrt(((n * -2.0) * ((U - U_42_) * ((l_m * l_m) * (n * U))))) / Om;
} 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((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))) tmp = 0 if Om <= -9.5e-123: tmp = t_1 elif Om <= 4e-308: tmp = math.sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / Om))) elif Om <= 6.6e-81: tmp = math.sqrt(((n * -2.0) * ((U - U_42_) * ((l_m * l_m) * (n * U))))) / 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(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * -2.0)))))))) tmp = 0.0 if (Om <= -9.5e-123) tmp = t_1; elseif (Om <= 4e-308) tmp = sqrt(Float64(n * Float64(Float64(Float64(2.0 * Float64(U * Float64(U_42_ * Float64(n * Float64(l_m * l_m))))) / Om) / Om))); elseif (Om <= 6.6e-81) tmp = Float64(sqrt(Float64(Float64(n * -2.0) * Float64(Float64(U - U_42_) * Float64(Float64(l_m * l_m) * Float64(n * U))))) / Om); 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((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))); tmp = 0.0; if (Om <= -9.5e-123) tmp = t_1; elseif (Om <= 4e-308) tmp = sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / Om))); elseif (Om <= 6.6e-81) tmp = sqrt(((n * -2.0) * ((U - U_42_) * ((l_m * l_m) * (n * U))))) / Om; 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 * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[Om, -9.5e-123], t$95$1, If[LessEqual[Om, 4e-308], N[Sqrt[N[(n * N[(N[(N[(2.0 * N[(U * N[(U$42$ * N[(n * N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, 6.6e-81], N[(N[Sqrt[N[(N[(n * -2.0), $MachinePrecision] * N[(N[(U - U$42$), $MachinePrecision] * N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Om), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := \sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot -2\right)\right)\right)\right)\right)}\\
\mathbf{if}\;Om \leq -9.5 \cdot 10^{-123}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;Om \leq 4 \cdot 10^{-308}:\\
\;\;\;\;\sqrt{n \cdot \frac{\frac{2 \cdot \left(U \cdot \left(U* \cdot \left(n \cdot \left(l\_m \cdot l\_m\right)\right)\right)\right)}{Om}}{Om}}\\
\mathbf{elif}\;Om \leq 6.6 \cdot 10^{-81}:\\
\;\;\;\;\frac{\sqrt{\left(n \cdot -2\right) \cdot \left(\left(U - U*\right) \cdot \left(\left(l\_m \cdot l\_m\right) \cdot \left(n \cdot U\right)\right)\right)}}{Om}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if Om < -9.5000000000000002e-123 or 6.59999999999999975e-81 < Om Initial program 56.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified56.0%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6461.6%
Applied egg-rr61.6%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6461.7%
Applied egg-rr61.7%
Taylor expanded in n around 0
*-lowering-*.f6456.4%
Simplified56.4%
if -9.5000000000000002e-123 < Om < 4.00000000000000013e-308Initial program 32.5%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified53.7%
Taylor expanded in Om around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6442.7%
Simplified42.7%
associate-/r*N/A
/-lowering-/.f64N/A
associate-*r*N/A
associate-/l*N/A
associate-*r/N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6442.8%
Applied egg-rr42.8%
Taylor expanded in U around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6447.0%
Simplified47.0%
if 4.00000000000000013e-308 < Om < 6.59999999999999975e-81Initial program 40.1%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified42.8%
Taylor expanded in Om around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6434.3%
Simplified34.3%
associate-*r/N/A
sqrt-divN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
/-lowering-/.f64N/A
Applied egg-rr50.1%
Final simplification54.5%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (or (<= Om -1.2e+151) (not (<= Om 1.8e+123)))
(sqrt (* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 Om) (* l_m -2.0))))))))
(sqrt
(* (* 2.0 U) (* n (+ t (/ (* (* l_m l_m) (- (* U* (/ n 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 ((Om <= -1.2e+151) || !(Om <= 1.8e+123)) {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / 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 ((om <= (-1.2d+151)) .or. (.not. (om <= 1.8d+123))) then
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (l_m * (-2.0d0)))))))))
else
tmp = sqrt(((2.0d0 * u) * (n * (t + (((l_m * l_m) * ((u_42 * (n / om)) - 2.0d0)) / 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 ((Om <= -1.2e+151) || !(Om <= 1.8e+123)) {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = Math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om)))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if (Om <= -1.2e+151) or not (Om <= 1.8e+123): tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))) else: tmp = math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if ((Om <= -1.2e+151) || !(Om <= 1.8e+123)) tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * -2.0)))))))); else tmp = sqrt(Float64(Float64(2.0 * U) * Float64(n * Float64(t + Float64(Float64(Float64(l_m * l_m) * Float64(Float64(U_42_ * Float64(n / Om)) - 2.0)) / 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 ((Om <= -1.2e+151) || ~((Om <= 1.8e+123))) tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))); else tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[Or[LessEqual[Om, -1.2e+151], N[Not[LessEqual[Om, 1.8e+123]], $MachinePrecision]], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * U), $MachinePrecision] * N[(n * N[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(N[(U$42$ * N[(n / Om), $MachinePrecision]), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -1.2 \cdot 10^{+151} \lor \neg \left(Om \leq 1.8 \cdot 10^{+123}\right):\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot -2\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot U\right) \cdot \left(n \cdot \left(t + \frac{\left(l\_m \cdot l\_m\right) \cdot \left(U* \cdot \frac{n}{Om} - 2\right)}{Om}\right)\right)}\\
\end{array}
\end{array}
if Om < -1.20000000000000005e151 or 1.79999999999999999e123 < Om Initial program 61.4%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified59.6%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6470.4%
Applied egg-rr70.4%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6470.4%
Applied egg-rr70.4%
Taylor expanded in n around 0
*-lowering-*.f6469.6%
Simplified69.6%
if -1.20000000000000005e151 < Om < 1.79999999999999999e123Initial program 46.7%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified50.8%
Taylor expanded in U around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified53.9%
Final simplification59.4%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 2.7e-184)
(sqrt
(* (+ t (* (* (/ l_m Om) (* n (/ l_m Om))) (- U* U))) (* n (* 2.0 U))))
(sqrt
(*
n
(*
2.0
(*
U
(+
t
(* l_m (* (/ 1.0 Om) (* l_m (+ -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.7e-184) {
tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * (-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.7d-184) then
tmp = sqrt(((t + (((l_m / om) * (n * (l_m / om))) * (u_42 - u))) * (n * (2.0d0 * u))))
else
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (l_m * ((-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.7e-184) {
tmp = Math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * (-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.7e-184: tmp = math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))) else: tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * (-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.7e-184) tmp = sqrt(Float64(Float64(t + Float64(Float64(Float64(l_m / Om) * Float64(n * Float64(l_m / Om))) * Float64(U_42_ - U))) * Float64(n * Float64(2.0 * U)))); else tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * 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.7e-184) tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))); else tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * (-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.7e-184], N[Sqrt[N[(N[(t + N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(n * N[(2.0 * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * N[(-2.0 + N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $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.7 \cdot 10^{-184}:\\
\;\;\;\;\sqrt{\left(t + \left(\frac{l\_m}{Om} \cdot \left(n \cdot \frac{l\_m}{Om}\right)\right) \cdot \left(U* - U\right)\right) \cdot \left(n \cdot \left(2 \cdot U\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot \left(-2 + \frac{n}{\frac{Om}{U* - U}}\right)\right)\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 2.7000000000000001e-184Initial program 54.3%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr55.3%
Taylor expanded in t around inf
Simplified54.8%
if 2.7000000000000001e-184 < l Initial program 47.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified57.8%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6462.8%
Applied egg-rr62.8%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6462.9%
Applied egg-rr62.9%
Final simplification57.9%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (or (<= Om -8e-28) (not (<= Om 2.4e-81))) (sqrt (* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 Om) (* l_m -2.0)))))))) (sqrt (* n (/ (* (* l_m -2.0) (* l_m (/ (* U (* n (- U U*))) Om))) Om)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if ((Om <= -8e-28) || !(Om <= 2.4e-81)) {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = sqrt((n * (((l_m * -2.0) * (l_m * ((U * (n * (U - U_42_))) / Om))) / 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 ((om <= (-8d-28)) .or. (.not. (om <= 2.4d-81))) then
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (l_m * (-2.0d0)))))))))
else
tmp = sqrt((n * (((l_m * (-2.0d0)) * (l_m * ((u * (n * (u - u_42))) / om))) / 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 ((Om <= -8e-28) || !(Om <= 2.4e-81)) {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = Math.sqrt((n * (((l_m * -2.0) * (l_m * ((U * (n * (U - U_42_))) / Om))) / Om)));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if (Om <= -8e-28) or not (Om <= 2.4e-81): tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))) else: tmp = math.sqrt((n * (((l_m * -2.0) * (l_m * ((U * (n * (U - U_42_))) / Om))) / Om))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if ((Om <= -8e-28) || !(Om <= 2.4e-81)) tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * -2.0)))))))); else tmp = sqrt(Float64(n * Float64(Float64(Float64(l_m * -2.0) * Float64(l_m * Float64(Float64(U * Float64(n * Float64(U - U_42_))) / Om))) / 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 ((Om <= -8e-28) || ~((Om <= 2.4e-81))) tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))); else tmp = sqrt((n * (((l_m * -2.0) * (l_m * ((U * (n * (U - U_42_))) / Om))) / Om))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[Or[LessEqual[Om, -8e-28], N[Not[LessEqual[Om, 2.4e-81]], $MachinePrecision]], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(N[(N[(l$95$m * -2.0), $MachinePrecision] * N[(l$95$m * N[(N[(U * N[(n * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -8 \cdot 10^{-28} \lor \neg \left(Om \leq 2.4 \cdot 10^{-81}\right):\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot -2\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \frac{\left(l\_m \cdot -2\right) \cdot \left(l\_m \cdot \frac{U \cdot \left(n \cdot \left(U - U*\right)\right)}{Om}\right)}{Om}}\\
\end{array}
\end{array}
if Om < -7.99999999999999977e-28 or 2.3999999999999999e-81 < Om Initial program 58.3%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified58.3%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6464.0%
Applied egg-rr64.0%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6464.0%
Applied egg-rr64.0%
Taylor expanded in n around 0
*-lowering-*.f6460.0%
Simplified60.0%
if -7.99999999999999977e-28 < Om < 2.3999999999999999e-81Initial program 38.6%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified44.7%
Taylor expanded in Om around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6435.7%
Simplified35.7%
associate-/r*N/A
/-lowering-/.f64N/A
associate-*r*N/A
associate-/l*N/A
associate-*r/N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6436.0%
Applied egg-rr36.0%
associate-*l*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
*-commutativeN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f6441.2%
Applied egg-rr41.2%
Taylor expanded in n around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f6444.0%
Simplified44.0%
Final simplification54.8%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= l_m 1.42e-184)
(sqrt
(* (+ t (* (* (/ l_m Om) (* n (/ l_m Om))) (- U* U))) (* n (* 2.0 U))))
(sqrt
(*
n
(*
2.0
(* U (+ t (* (* l_m (/ l_m Om)) (+ -2.0 (* n (/ (- U* U) 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 <= 1.42e-184) {
tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else {
tmp = sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 + (n * ((U_42_ - U) / 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 <= 1.42d-184) then
tmp = sqrt(((t + (((l_m / om) * (n * (l_m / om))) * (u_42 - u))) * (n * (2.0d0 * u))))
else
tmp = sqrt((n * (2.0d0 * (u * (t + ((l_m * (l_m / om)) * ((-2.0d0) + (n * ((u_42 - u) / 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 <= 1.42e-184) {
tmp = Math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else {
tmp = Math.sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 + (n * ((U_42_ - U) / Om)))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 1.42e-184: tmp = math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))) else: tmp = math.sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 + (n * ((U_42_ - U) / Om))))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 1.42e-184) tmp = sqrt(Float64(Float64(t + Float64(Float64(Float64(l_m / Om) * Float64(n * Float64(l_m / Om))) * Float64(U_42_ - U))) * Float64(n * Float64(2.0 * U)))); else tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(Float64(l_m * Float64(l_m / Om)) * Float64(-2.0 + Float64(n * Float64(Float64(U_42_ - U) / 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 <= 1.42e-184) tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))); else tmp = sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 + (n * ((U_42_ - U) / 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, 1.42e-184], N[Sqrt[N[(N[(t + N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(n * N[(2.0 * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(N[(l$95$m * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision] * N[(-2.0 + N[(n * N[(N[(U$42$ - U), $MachinePrecision] / Om), $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 1.42 \cdot 10^{-184}:\\
\;\;\;\;\sqrt{\left(t + \left(\frac{l\_m}{Om} \cdot \left(n \cdot \frac{l\_m}{Om}\right)\right) \cdot \left(U* - U\right)\right) \cdot \left(n \cdot \left(2 \cdot U\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + \left(l\_m \cdot \frac{l\_m}{Om}\right) \cdot \left(-2 + n \cdot \frac{U* - U}{Om}\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 1.41999999999999993e-184Initial program 54.3%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr55.3%
Taylor expanded in t around inf
Simplified54.8%
if 1.41999999999999993e-184 < l Initial program 47.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified57.8%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6462.8%
Applied egg-rr62.8%
Final simplification57.9%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (or (<= Om -9.5e-121) (not (<= Om 4.4e-81))) (sqrt (* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 Om) (* l_m -2.0)))))))) (sqrt (* n (/ (/ (* 2.0 (* U (* U* (* n (* l_m l_m))))) Om) Om)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if ((Om <= -9.5e-121) || !(Om <= 4.4e-81)) {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / 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 ((om <= (-9.5d-121)) .or. (.not. (om <= 4.4d-81))) then
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (l_m * (-2.0d0)))))))))
else
tmp = sqrt((n * (((2.0d0 * (u * (u_42 * (n * (l_m * l_m))))) / om) / 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 ((Om <= -9.5e-121) || !(Om <= 4.4e-81)) {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = Math.sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / Om)));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if (Om <= -9.5e-121) or not (Om <= 4.4e-81): tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))) else: tmp = math.sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / Om))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if ((Om <= -9.5e-121) || !(Om <= 4.4e-81)) tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * -2.0)))))))); else tmp = sqrt(Float64(n * Float64(Float64(Float64(2.0 * Float64(U * Float64(U_42_ * Float64(n * Float64(l_m * l_m))))) / Om) / 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 ((Om <= -9.5e-121) || ~((Om <= 4.4e-81))) tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))); else tmp = sqrt((n * (((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / Om) / Om))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[Or[LessEqual[Om, -9.5e-121], N[Not[LessEqual[Om, 4.4e-81]], $MachinePrecision]], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(N[(N[(2.0 * N[(U * N[(U$42$ * N[(n * N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -9.5 \cdot 10^{-121} \lor \neg \left(Om \leq 4.4 \cdot 10^{-81}\right):\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot -2\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \frac{\frac{2 \cdot \left(U \cdot \left(U* \cdot \left(n \cdot \left(l\_m \cdot l\_m\right)\right)\right)\right)}{Om}}{Om}}\\
\end{array}
\end{array}
if Om < -9.4999999999999994e-121 or 4.3999999999999998e-81 < Om Initial program 56.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified56.0%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6461.6%
Applied egg-rr61.6%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6461.7%
Applied egg-rr61.7%
Taylor expanded in n around 0
*-lowering-*.f6456.4%
Simplified56.4%
if -9.4999999999999994e-121 < Om < 4.3999999999999998e-81Initial program 36.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified47.4%
Taylor expanded in Om around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
associate-/r*N/A
/-lowering-/.f64N/A
associate-*r*N/A
associate-/l*N/A
associate-*r/N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6438.3%
Applied egg-rr38.3%
Taylor expanded in U around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6441.8%
Simplified41.8%
Final simplification52.8%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= U 2.4e-281)
(sqrt
(* (+ t (* (* (/ l_m Om) (* n (/ l_m Om))) (- U* U))) (* n (* 2.0 U))))
(sqrt
(* (* 2.0 U) (* n (+ t (/ (* (* l_m l_m) (- (* U* (/ n 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 (U <= 2.4e-281) {
tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else {
tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / 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 (u <= 2.4d-281) then
tmp = sqrt(((t + (((l_m / om) * (n * (l_m / om))) * (u_42 - u))) * (n * (2.0d0 * u))))
else
tmp = sqrt(((2.0d0 * u) * (n * (t + (((l_m * l_m) * ((u_42 * (n / om)) - 2.0d0)) / 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 (U <= 2.4e-281) {
tmp = Math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U))));
} else {
tmp = Math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om)))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U <= 2.4e-281: tmp = math.sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))) else: tmp = math.sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U <= 2.4e-281) tmp = sqrt(Float64(Float64(t + Float64(Float64(Float64(l_m / Om) * Float64(n * Float64(l_m / Om))) * Float64(U_42_ - U))) * Float64(n * Float64(2.0 * U)))); else tmp = sqrt(Float64(Float64(2.0 * U) * Float64(n * Float64(t + Float64(Float64(Float64(l_m * l_m) * Float64(Float64(U_42_ * Float64(n / Om)) - 2.0)) / 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 (U <= 2.4e-281) tmp = sqrt(((t + (((l_m / Om) * (n * (l_m / Om))) * (U_42_ - U))) * (n * (2.0 * U)))); else tmp = sqrt(((2.0 * U) * (n * (t + (((l_m * l_m) * ((U_42_ * (n / Om)) - 2.0)) / Om))))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[U, 2.4e-281], N[Sqrt[N[(N[(t + N[(N[(N[(l$95$m / Om), $MachinePrecision] * N[(n * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(n * N[(2.0 * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * U), $MachinePrecision] * N[(n * N[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(N[(U$42$ * N[(n / Om), $MachinePrecision]), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U \leq 2.4 \cdot 10^{-281}:\\
\;\;\;\;\sqrt{\left(t + \left(\frac{l\_m}{Om} \cdot \left(n \cdot \frac{l\_m}{Om}\right)\right) \cdot \left(U* - U\right)\right) \cdot \left(n \cdot \left(2 \cdot U\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot U\right) \cdot \left(n \cdot \left(t + \frac{\left(l\_m \cdot l\_m\right) \cdot \left(U* \cdot \frac{n}{Om} - 2\right)}{Om}\right)\right)}\\
\end{array}
\end{array}
if U < 2.4e-281Initial program 52.1%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr53.5%
Taylor expanded in t around inf
Simplified59.4%
if 2.4e-281 < U Initial program 51.7%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified54.9%
Taylor expanded in U around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified59.1%
Final simplification59.2%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= Om 5.2e+42)
(sqrt
(* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 Om) (* U* (/ (* n l_m) Om)))))))))
(sqrt
(* n (* 2.0 (* U (+ t (* (* l_m (/ l_m Om)) (- -2.0 (/ (* n U) Om))))))))))l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
double tmp;
if (Om <= 5.2e+42) {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om)))))))));
} else {
tmp = sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 - ((n * U) / 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 (om <= 5.2d+42) then
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (u_42 * ((n * l_m) / om)))))))))
else
tmp = sqrt((n * (2.0d0 * (u * (t + ((l_m * (l_m / om)) * ((-2.0d0) - ((n * u) / 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 (Om <= 5.2e+42) {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om)))))))));
} else {
tmp = Math.sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 - ((n * U) / Om))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if Om <= 5.2e+42: tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om))))))))) else: tmp = math.sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 - ((n * U) / Om)))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (Om <= 5.2e+42) tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(U_42_ * Float64(Float64(n * l_m) / Om))))))))); else tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(Float64(l_m * Float64(l_m / Om)) * Float64(-2.0 - Float64(Float64(n * U) / 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 (Om <= 5.2e+42) tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om))))))))); else tmp = sqrt((n * (2.0 * (U * (t + ((l_m * (l_m / Om)) * (-2.0 - ((n * U) / Om)))))))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[Om, 5.2e+42], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(U$42$ * N[(N[(n * l$95$m), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(N[(l$95$m * N[(l$95$m / Om), $MachinePrecision]), $MachinePrecision] * N[(-2.0 - N[(N[(n * U), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;Om \leq 5.2 \cdot 10^{+42}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(U* \cdot \frac{n \cdot l\_m}{Om}\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + \left(l\_m \cdot \frac{l\_m}{Om}\right) \cdot \left(-2 - \frac{n \cdot U}{Om}\right)\right)\right)\right)}\\
\end{array}
\end{array}
if Om < 5.1999999999999998e42Initial program 49.0%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified51.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6454.8%
Applied egg-rr54.8%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6455.4%
Applied egg-rr55.4%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6450.6%
Simplified50.6%
if 5.1999999999999998e42 < Om Initial program 59.1%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified58.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6467.0%
Applied egg-rr67.0%
Taylor expanded in U around inf
/-lowering-/.f64N/A
*-lowering-*.f6461.9%
Simplified61.9%
Final simplification53.8%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(if (<= Om 5.1e+42)
(sqrt
(* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 Om) (* U* (/ (* n l_m) Om)))))))))
(sqrt (* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 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_) {
double tmp;
if (Om <= 5.1e+42) {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om)))))))));
} else {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -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 (om <= 5.1d+42) then
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (u_42 * ((n * l_m) / om)))))))))
else
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (l_m * (-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 (Om <= 5.1e+42) {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om)))))))));
} else {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if Om <= 5.1e+42: tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om))))))))) else: tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (Om <= 5.1e+42) tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(U_42_ * Float64(Float64(n * l_m) / Om))))))))); else tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * -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 (Om <= 5.1e+42) tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (U_42_ * ((n * l_m) / Om))))))))); else tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -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[Om, 5.1e+42], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(U$42$ * N[(N[(n * l$95$m), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;Om \leq 5.1 \cdot 10^{+42}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(U* \cdot \frac{n \cdot l\_m}{Om}\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot -2\right)\right)\right)\right)\right)}\\
\end{array}
\end{array}
if Om < 5.0999999999999999e42Initial program 49.0%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified51.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6454.8%
Applied egg-rr54.8%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6455.4%
Applied egg-rr55.4%
Taylor expanded in U* around inf
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6450.6%
Simplified50.6%
if 5.0999999999999999e42 < Om Initial program 59.1%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified58.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6467.0%
Applied egg-rr67.0%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6467.1%
Applied egg-rr67.1%
Taylor expanded in n around 0
*-lowering-*.f6461.4%
Simplified61.4%
Final simplification53.7%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= l_m 1.85e+264) (sqrt (* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 Om) (* l_m -2.0)))))))) (sqrt (* n (/ (* 2.0 (* U (* U* (* n (* l_m l_m))))) (* Om 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 <= 1.85e+264) {
tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = sqrt((n * ((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / (Om * 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 <= 1.85d+264) then
tmp = sqrt((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / om) * (l_m * (-2.0d0)))))))))
else
tmp = sqrt((n * ((2.0d0 * (u * (u_42 * (n * (l_m * l_m))))) / (om * 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 <= 1.85e+264) {
tmp = Math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
} else {
tmp = Math.sqrt((n * ((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / (Om * Om))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if l_m <= 1.85e+264: tmp = math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))) else: tmp = math.sqrt((n * ((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / (Om * Om)))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (l_m <= 1.85e+264) tmp = sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * -2.0)))))))); else tmp = sqrt(Float64(n * Float64(Float64(2.0 * Float64(U * Float64(U_42_ * Float64(n * Float64(l_m * l_m))))) / Float64(Om * 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 <= 1.85e+264) tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0)))))))); else tmp = sqrt((n * ((2.0 * (U * (U_42_ * (n * (l_m * l_m))))) / (Om * 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, 1.85e+264], N[Sqrt[N[(n * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(n * N[(N[(2.0 * N[(U * N[(U$42$ * N[(n * N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;l\_m \leq 1.85 \cdot 10^{+264}:\\
\;\;\;\;\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot -2\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot \frac{2 \cdot \left(U \cdot \left(U* \cdot \left(n \cdot \left(l\_m \cdot l\_m\right)\right)\right)\right)}{Om \cdot Om}}\\
\end{array}
\end{array}
if l < 1.85e264Initial program 53.4%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified53.3%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6457.9%
Applied egg-rr57.9%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6458.4%
Applied egg-rr58.4%
Taylor expanded in n around 0
*-lowering-*.f6449.2%
Simplified49.2%
if 1.85e264 < l Initial program 23.1%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified65.0%
Taylor expanded in U* around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6463.8%
Simplified63.8%
Final simplification49.9%
l_m = (fabs.f64 l)
(FPCore (n U t l_m Om U*)
:precision binary64
(let* ((t_1 (+ t (/ (* (* l_m l_m) -2.0) Om))))
(if (<= U -1.9e-180)
(sqrt (* (* U (* 2.0 n)) t_1))
(sqrt (* 2.0 (* U (* n 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 = t + (((l_m * l_m) * -2.0) / Om);
double tmp;
if (U <= -1.9e-180) {
tmp = sqrt(((U * (2.0 * n)) * t_1));
} else {
tmp = sqrt((2.0 * (U * (n * 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 = t + (((l_m * l_m) * (-2.0d0)) / om)
if (u <= (-1.9d-180)) then
tmp = sqrt(((u * (2.0d0 * n)) * t_1))
else
tmp = sqrt((2.0d0 * (u * (n * 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 = t + (((l_m * l_m) * -2.0) / Om);
double tmp;
if (U <= -1.9e-180) {
tmp = Math.sqrt(((U * (2.0 * n)) * t_1));
} else {
tmp = Math.sqrt((2.0 * (U * (n * t_1))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): t_1 = t + (((l_m * l_m) * -2.0) / Om) tmp = 0 if U <= -1.9e-180: tmp = math.sqrt(((U * (2.0 * n)) * t_1)) else: tmp = math.sqrt((2.0 * (U * (n * t_1)))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) t_1 = Float64(t + Float64(Float64(Float64(l_m * l_m) * -2.0) / Om)) tmp = 0.0 if (U <= -1.9e-180) tmp = sqrt(Float64(Float64(U * Float64(2.0 * n)) * t_1)); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * t_1)))); end return tmp end
l_m = abs(l); function tmp_2 = code(n, U, t, l_m, Om, U_42_) t_1 = t + (((l_m * l_m) * -2.0) / Om); tmp = 0.0; if (U <= -1.9e-180) tmp = sqrt(((U * (2.0 * n)) * t_1)); else tmp = sqrt((2.0 * (U * (n * 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[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * -2.0), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[U, -1.9e-180], N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
t_1 := t + \frac{\left(l\_m \cdot l\_m\right) \cdot -2}{Om}\\
\mathbf{if}\;U \leq -1.9 \cdot 10^{-180}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot t\_1}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot t\_1\right)\right)}\\
\end{array}
\end{array}
if U < -1.9e-180Initial program 57.1%
Taylor expanded in Om around inf
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6449.7%
Simplified49.7%
if -1.9e-180 < U Initial program 48.5%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified50.4%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6456.2%
Applied egg-rr56.2%
Taylor expanded in n around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified44.0%
Taylor expanded in n around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6445.1%
Simplified45.1%
Final simplification46.9%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U -7.5e+38) (pow (* n (* 2.0 (* U t))) 0.5) (sqrt (* 2.0 (* U (* n (+ t (/ (* (* l_m l_m) -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 (U <= -7.5e+38) {
tmp = pow((n * (2.0 * (U * t))), 0.5);
} else {
tmp = sqrt((2.0 * (U * (n * (t + (((l_m * l_m) * -2.0) / 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 (u <= (-7.5d+38)) then
tmp = (n * (2.0d0 * (u * t))) ** 0.5d0
else
tmp = sqrt((2.0d0 * (u * (n * (t + (((l_m * l_m) * (-2.0d0)) / 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 (U <= -7.5e+38) {
tmp = Math.pow((n * (2.0 * (U * t))), 0.5);
} else {
tmp = Math.sqrt((2.0 * (U * (n * (t + (((l_m * l_m) * -2.0) / Om))))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U <= -7.5e+38: tmp = math.pow((n * (2.0 * (U * t))), 0.5) else: tmp = math.sqrt((2.0 * (U * (n * (t + (((l_m * l_m) * -2.0) / Om)))))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U <= -7.5e+38) tmp = Float64(n * Float64(2.0 * Float64(U * t))) ^ 0.5; else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(t + Float64(Float64(Float64(l_m * l_m) * -2.0) / 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 (U <= -7.5e+38) tmp = (n * (2.0 * (U * t))) ^ 0.5; else tmp = sqrt((2.0 * (U * (n * (t + (((l_m * l_m) * -2.0) / Om)))))); end tmp_2 = tmp; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := If[LessEqual[U, -7.5e+38], N[Power[N[(n * N[(2.0 * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t + N[(N[(N[(l$95$m * l$95$m), $MachinePrecision] * -2.0), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U \leq -7.5 \cdot 10^{+38}:\\
\;\;\;\;{\left(n \cdot \left(2 \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(t + \frac{\left(l\_m \cdot l\_m\right) \cdot -2}{Om}\right)\right)\right)}\\
\end{array}
\end{array}
if U < -7.4999999999999999e38Initial program 63.2%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified56.3%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f6452.7%
Simplified52.7%
pow1/2N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6457.5%
Applied egg-rr57.5%
if -7.4999999999999999e38 < U Initial program 49.7%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified53.4%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6458.1%
Applied egg-rr58.1%
Taylor expanded in n around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified43.5%
Taylor expanded in n around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6444.0%
Simplified44.0%
Final simplification46.2%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (sqrt (* n (* 2.0 (* U (+ t (* l_m (* (/ 1.0 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((n * (2.0 * (U * (t + (l_m * ((1.0 / 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((n * (2.0d0 * (u * (t + (l_m * ((1.0d0 / 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((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))));
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): return math.sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / Om) * (l_m * -2.0))))))))
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) return sqrt(Float64(n * Float64(2.0 * Float64(U * Float64(t + Float64(l_m * Float64(Float64(1.0 / Om) * Float64(l_m * -2.0)))))))) end
l_m = abs(l); function tmp = code(n, U, t, l_m, Om, U_42_) tmp = sqrt((n * (2.0 * (U * (t + (l_m * ((1.0 / 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 * N[(2.0 * N[(U * N[(t + N[(l$95$m * N[(N[(1.0 / Om), $MachinePrecision] * N[(l$95$m * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\sqrt{n \cdot \left(2 \cdot \left(U \cdot \left(t + l\_m \cdot \left(\frac{1}{Om} \cdot \left(l\_m \cdot -2\right)\right)\right)\right)\right)}
\end{array}
Initial program 51.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified53.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6458.2%
Applied egg-rr58.2%
associate-*l*N/A
div-invN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f6458.7%
Applied egg-rr58.7%
Taylor expanded in n around 0
*-lowering-*.f6448.0%
Simplified48.0%
Final simplification48.0%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U* 5e-233) (sqrt (* (* U (* 2.0 n)) t)) (sqrt (* U (* t (* 2.0 n))))))
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_ <= 5e-233) {
tmp = sqrt(((U * (2.0 * n)) * t));
} else {
tmp = sqrt((U * (t * (2.0 * n))));
}
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 <= 5d-233) then
tmp = sqrt(((u * (2.0d0 * n)) * t))
else
tmp = sqrt((u * (t * (2.0d0 * n))))
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_ <= 5e-233) {
tmp = Math.sqrt(((U * (2.0 * n)) * t));
} else {
tmp = Math.sqrt((U * (t * (2.0 * n))));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U_42_ <= 5e-233: tmp = math.sqrt(((U * (2.0 * n)) * t)) else: tmp = math.sqrt((U * (t * (2.0 * n)))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U_42_ <= 5e-233) tmp = sqrt(Float64(Float64(U * Float64(2.0 * n)) * t)); else tmp = sqrt(Float64(U * Float64(t * Float64(2.0 * n)))); 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_ <= 5e-233) tmp = sqrt(((U * (2.0 * n)) * t)); else tmp = sqrt((U * (t * (2.0 * n)))); 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$, 5e-233], N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(U * N[(t * N[(2.0 * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U* \leq 5 \cdot 10^{-233}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot t}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(t \cdot \left(2 \cdot n\right)\right)}\\
\end{array}
\end{array}
if U* < 5.00000000000000012e-233Initial program 50.3%
Taylor expanded in t around inf
Simplified36.8%
if 5.00000000000000012e-233 < U* Initial program 53.8%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified56.7%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f6441.8%
Simplified41.8%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6445.0%
Applied egg-rr45.0%
Final simplification40.5%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (if (<= U* 7.4e-233) (sqrt (* (* U (* 2.0 n)) t)) (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_) {
double tmp;
if (U_42_ <= 7.4e-233) {
tmp = sqrt(((U * (2.0 * n)) * t));
} else {
tmp = sqrt(((2.0 * U) * (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_42 <= 7.4d-233) then
tmp = sqrt(((u * (2.0d0 * n)) * t))
else
tmp = sqrt(((2.0d0 * u) * (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_42_ <= 7.4e-233) {
tmp = Math.sqrt(((U * (2.0 * n)) * t));
} else {
tmp = Math.sqrt(((2.0 * U) * (n * t)));
}
return tmp;
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): tmp = 0 if U_42_ <= 7.4e-233: tmp = math.sqrt(((U * (2.0 * n)) * t)) else: tmp = math.sqrt(((2.0 * U) * (n * t))) return tmp
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) tmp = 0.0 if (U_42_ <= 7.4e-233) tmp = sqrt(Float64(Float64(U * Float64(2.0 * n)) * t)); else tmp = sqrt(Float64(Float64(2.0 * U) * 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_42_ <= 7.4e-233) tmp = sqrt(((U * (2.0 * n)) * t)); else tmp = sqrt(((2.0 * U) * (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$42$, 7.4e-233], N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * U), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\begin{array}{l}
\mathbf{if}\;U* \leq 7.4 \cdot 10^{-233}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot t}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot U\right) \cdot \left(n \cdot t\right)}\\
\end{array}
\end{array}
if U* < 7.3999999999999996e-233Initial program 50.3%
Taylor expanded in t around inf
Simplified36.8%
if 7.3999999999999996e-233 < U* Initial program 53.8%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified56.7%
Taylor expanded in t around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6445.0%
Simplified45.0%
Final simplification40.5%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (pow (* n (* 2.0 (* U t))) 0.5))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
return pow((n * (2.0 * (U * t))), 0.5);
}
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 = (n * (2.0d0 * (u * t))) ** 0.5d0
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.pow((n * (2.0 * (U * t))), 0.5);
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): return math.pow((n * (2.0 * (U * t))), 0.5)
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) return Float64(n * Float64(2.0 * Float64(U * t))) ^ 0.5 end
l_m = abs(l); function tmp = code(n, U, t, l_m, Om, U_42_) tmp = (n * (2.0 * (U * t))) ^ 0.5; end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := N[Power[N[(n * N[(2.0 * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
{\left(n \cdot \left(2 \cdot \left(U \cdot t\right)\right)\right)}^{0.5}
\end{array}
Initial program 51.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified53.9%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f6438.2%
Simplified38.2%
pow1/2N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6439.3%
Applied egg-rr39.3%
l_m = (fabs.f64 l) (FPCore (n U t l_m Om U*) :precision binary64 (sqrt (* n (* 2.0 (* U t)))))
l_m = fabs(l);
double code(double n, double U, double t, double l_m, double Om, double U_42_) {
return sqrt((n * (2.0 * (U * 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((n * (2.0d0 * (u * 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((n * (2.0 * (U * t))));
}
l_m = math.fabs(l) def code(n, U, t, l_m, Om, U_42_): return math.sqrt((n * (2.0 * (U * t))))
l_m = abs(l) function code(n, U, t, l_m, Om, U_42_) return sqrt(Float64(n * Float64(2.0 * Float64(U * t)))) end
l_m = abs(l); function tmp = code(n, U, t, l_m, Om, U_42_) tmp = sqrt((n * (2.0 * (U * t)))); end
l_m = N[Abs[l], $MachinePrecision] code[n_, U_, t_, l$95$m_, Om_, U$42$_] := N[Sqrt[N[(n * N[(2.0 * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
\sqrt{n \cdot \left(2 \cdot \left(U \cdot t\right)\right)}
\end{array}
Initial program 51.9%
sqrt-lowering-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate--l+N/A
+-lowering-+.f64N/A
Simplified53.9%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-lowering-*.f6438.2%
Simplified38.2%
herbie shell --seed 2024129
(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*))))))