
(FPCore (n U t l Om U*) :precision binary64 (sqrt (* (* (* 2.0 n) U) (- (- t (* 2.0 (/ (* l l) Om))) (* (* n (pow (/ l Om) 2.0)) (- U U*))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * pow((l / Om), 2.0)) * (U - U_42_)))));
}
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt((((2.0d0 * n) * u) * ((t - (2.0d0 * ((l * l) / om))) - ((n * ((l / om) ** 2.0d0)) * (u - u_42)))))
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * Math.pow((l / Om), 2.0)) * (U - U_42_)))));
}
def code(n, U, t, l, Om, U_42_): return math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * math.pow((l / Om), 2.0)) * (U - U_42_)))))
function code(n, U, t, l, Om, U_42_) return sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) - Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U - U_42_))))) end
function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * ((l / Om) ^ 2.0)) * (U - U_42_))))); end
code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) - \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U - U*\right)\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (n U t l Om U*) :precision binary64 (sqrt (* (* (* 2.0 n) U) (- (- t (* 2.0 (/ (* l l) Om))) (* (* n (pow (/ l Om) 2.0)) (- U U*))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * pow((l / Om), 2.0)) * (U - U_42_)))));
}
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt((((2.0d0 * n) * u) * ((t - (2.0d0 * ((l * l) / om))) - ((n * ((l / om) ** 2.0d0)) * (u - u_42)))))
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * Math.pow((l / Om), 2.0)) * (U - U_42_)))));
}
def code(n, U, t, l, Om, U_42_): return math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * math.pow((l / Om), 2.0)) * (U - U_42_)))))
function code(n, U, t, l, Om, U_42_) return sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) - Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U - U_42_))))) end
function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * ((l / Om) ^ 2.0)) * (U - U_42_))))); end
code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) - \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U - U*\right)\right)}
\end{array}
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(*
(* (* 2.0 n) U)
(+
(- t (* 2.0 (/ (* l l) Om)))
(* (* n (pow (/ l Om) 2.0)) (- U* U))))))
(if (<= t_1 5e-27)
(sqrt
(*
(* 2.0 n)
(* U (+ t (* (/ l Om) (fma l -2.0 (* (/ l Om) (* n (- U* U)))))))))
(if (<= t_1 2e+305)
(sqrt t_1)
(*
(* l (sqrt 2.0))
(sqrt (* n (* U (- (/ n (/ (* Om Om) (- U* U))) (/ 2.0 Om))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = ((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) + ((n * pow((l / Om), 2.0)) * (U_42_ - U)));
double tmp;
if (t_1 <= 5e-27) {
tmp = sqrt(((2.0 * n) * (U * (t + ((l / Om) * fma(l, -2.0, ((l / Om) * (n * (U_42_ - U)))))))));
} else if (t_1 <= 2e+305) {
tmp = sqrt(t_1);
} else {
tmp = (l * sqrt(2.0)) * sqrt((n * (U * ((n / ((Om * Om) / (U_42_ - U))) - (2.0 / Om)))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = 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_42_ - U)))) tmp = 0.0 if (t_1 <= 5e-27) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l / Om) * fma(l, -2.0, Float64(Float64(l / Om) * Float64(n * Float64(U_42_ - U))))))))); elseif (t_1 <= 2e+305) tmp = sqrt(t_1); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(n * Float64(U * Float64(Float64(n / Float64(Float64(Om * Om) / Float64(U_42_ - U))) - Float64(2.0 / Om)))))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = 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$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 5e-27], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l / Om), $MachinePrecision] * N[(l * -2.0 + N[(N[(l / Om), $MachinePrecision] * N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$1, 2e+305], N[Sqrt[t$95$1], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(n * N[(U * N[(N[(n / N[(N[(Om * Om), $MachinePrecision] / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \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)\\
\mathbf{if}\;t_1 \leq 5 \cdot 10^{-27}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{\ell}{Om} \cdot \mathsf{fma}\left(\ell, -2, \frac{\ell}{Om} \cdot \left(n \cdot \left(U* - U\right)\right)\right)\right)\right)}\\
\mathbf{elif}\;t_1 \leq 2 \cdot 10^{+305}:\\
\;\;\;\;\sqrt{t_1}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{n \cdot \left(U \cdot \left(\frac{n}{\frac{Om \cdot Om}{U* - U}} - \frac{2}{Om}\right)\right)}\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) < 5.0000000000000002e-27Initial program 45.7%
Simplified69.0%
if 5.0000000000000002e-27 < (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) < 1.9999999999999999e305Initial program 99.6%
if 1.9999999999999999e305 < (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) Initial program 26.2%
Simplified45.7%
Taylor expanded in l around inf 23.5%
associate-/l*23.8%
unpow223.8%
associate-*r/23.8%
metadata-eval23.8%
Simplified23.8%
Final simplification55.8%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(*
(* 2.0 n)
(* U (+ t (/ (* l (+ (/ (* n (* l U*)) Om) (* l -2.0))) Om)))))))
(if (<= l 6.5e+77)
t_1
(if (<= l 2.8e+130)
(sqrt (* (* -2.0 (* (* l l) (/ n Om))) (* U (- 2.0 (/ (* n U*) Om)))))
(if (<= l 2.3e+145)
t_1
(*
(* l (sqrt 2.0))
(sqrt (* n (* U (+ (/ (* n (- U* U)) (* Om Om)) (/ -2.0 Om)))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om)))));
double tmp;
if (l <= 6.5e+77) {
tmp = t_1;
} else if (l <= 2.8e+130) {
tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else if (l <= 2.3e+145) {
tmp = t_1;
} else {
tmp = (l * sqrt(2.0)) * sqrt((n * (U * (((n * (U_42_ - U)) / (Om * Om)) + (-2.0 / Om)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt(((2.0d0 * n) * (u * (t + ((l * (((n * (l * u_42)) / om) + (l * (-2.0d0)))) / om)))))
if (l <= 6.5d+77) then
tmp = t_1
else if (l <= 2.8d+130) then
tmp = sqrt((((-2.0d0) * ((l * l) * (n / om))) * (u * (2.0d0 - ((n * u_42) / om)))))
else if (l <= 2.3d+145) then
tmp = t_1
else
tmp = (l * sqrt(2.0d0)) * sqrt((n * (u * (((n * (u_42 - u)) / (om * om)) + ((-2.0d0) / om)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om)))));
double tmp;
if (l <= 6.5e+77) {
tmp = t_1;
} else if (l <= 2.8e+130) {
tmp = Math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else if (l <= 2.3e+145) {
tmp = t_1;
} else {
tmp = (l * Math.sqrt(2.0)) * Math.sqrt((n * (U * (((n * (U_42_ - U)) / (Om * Om)) + (-2.0 / Om)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om))))) tmp = 0 if l <= 6.5e+77: tmp = t_1 elif l <= 2.8e+130: tmp = math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))) elif l <= 2.3e+145: tmp = t_1 else: tmp = (l * math.sqrt(2.0)) * math.sqrt((n * (U * (((n * (U_42_ - U)) / (Om * Om)) + (-2.0 / Om))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l * Float64(Float64(Float64(n * Float64(l * U_42_)) / Om) + Float64(l * -2.0))) / Om))))) tmp = 0.0 if (l <= 6.5e+77) tmp = t_1; elseif (l <= 2.8e+130) tmp = sqrt(Float64(Float64(-2.0 * Float64(Float64(l * l) * Float64(n / Om))) * Float64(U * Float64(2.0 - Float64(Float64(n * U_42_) / Om))))); elseif (l <= 2.3e+145) tmp = t_1; else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(n * Float64(U * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) + Float64(-2.0 / Om)))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om))))); tmp = 0.0; if (l <= 6.5e+77) tmp = t_1; elseif (l <= 2.8e+130) tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))); elseif (l <= 2.3e+145) tmp = t_1; else tmp = (l * sqrt(2.0)) * sqrt((n * (U * (((n * (U_42_ - U)) / (Om * Om)) + (-2.0 / Om))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l * N[(N[(N[(n * N[(l * U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] + N[(l * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, 6.5e+77], t$95$1, If[LessEqual[l, 2.8e+130], N[Sqrt[N[(N[(-2.0 * N[(N[(l * l), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U * N[(2.0 - N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 2.3e+145], t$95$1, N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(n * N[(U * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{\ell \cdot \left(\frac{n \cdot \left(\ell \cdot U*\right)}{Om} + \ell \cdot -2\right)}{Om}\right)\right)}\\
\mathbf{if}\;\ell \leq 6.5 \cdot 10^{+77}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq 2.8 \cdot 10^{+130}:\\
\;\;\;\;\sqrt{\left(-2 \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{n}{Om}\right)\right) \cdot \left(U \cdot \left(2 - \frac{n \cdot U*}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.3 \cdot 10^{+145}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{n \cdot \left(U \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} + \frac{-2}{Om}\right)\right)}\\
\end{array}
\end{array}
if l < 6.5e77 or 2.7999999999999999e130 < l < 2.3e145Initial program 54.5%
Simplified61.2%
Taylor expanded in U around 0 60.1%
if 6.5e77 < l < 2.7999999999999999e130Initial program 41.0%
Simplified36.6%
Taylor expanded in l around -inf 68.2%
associate-/l*36.6%
associate-/r*37.0%
unpow237.0%
*-commutative37.0%
mul-1-neg37.0%
unsub-neg37.0%
associate-/l*37.0%
Simplified37.0%
*-un-lft-identity37.0%
associate-/r/37.0%
associate-/r/37.0%
Applied egg-rr37.0%
*-lft-identity37.0%
associate-*r*37.7%
unpow237.7%
associate-/r/62.8%
unpow262.8%
associate-*l/62.8%
associate-*l/62.8%
*-commutative62.8%
Simplified62.8%
Taylor expanded in U* around inf 62.8%
if 2.3e145 < l Initial program 9.3%
Simplified45.5%
Taylor expanded in l around inf 69.6%
sub-neg69.6%
unpow269.6%
associate-*r/69.6%
metadata-eval69.6%
distribute-neg-frac69.6%
metadata-eval69.6%
Simplified69.6%
Final simplification61.2%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(*
(* 2.0 n)
(* U (+ t (/ (* l (+ (/ (* n (* l U*)) Om) (* l -2.0))) Om)))))))
(if (<= l 4.5e+78)
t_1
(if (<= l 3.6e+130)
(sqrt (* (* -2.0 (* (* l l) (/ n Om))) (* U (- 2.0 (/ (* n U*) Om)))))
(if (<= l 2.4e+145)
t_1
(*
(* l (sqrt 2.0))
(sqrt (* n (* U (- (/ n (/ (* Om Om) (- U* U))) (/ 2.0 Om)))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om)))));
double tmp;
if (l <= 4.5e+78) {
tmp = t_1;
} else if (l <= 3.6e+130) {
tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else if (l <= 2.4e+145) {
tmp = t_1;
} else {
tmp = (l * sqrt(2.0)) * sqrt((n * (U * ((n / ((Om * Om) / (U_42_ - U))) - (2.0 / Om)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt(((2.0d0 * n) * (u * (t + ((l * (((n * (l * u_42)) / om) + (l * (-2.0d0)))) / om)))))
if (l <= 4.5d+78) then
tmp = t_1
else if (l <= 3.6d+130) then
tmp = sqrt((((-2.0d0) * ((l * l) * (n / om))) * (u * (2.0d0 - ((n * u_42) / om)))))
else if (l <= 2.4d+145) then
tmp = t_1
else
tmp = (l * sqrt(2.0d0)) * sqrt((n * (u * ((n / ((om * om) / (u_42 - u))) - (2.0d0 / om)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om)))));
double tmp;
if (l <= 4.5e+78) {
tmp = t_1;
} else if (l <= 3.6e+130) {
tmp = Math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else if (l <= 2.4e+145) {
tmp = t_1;
} else {
tmp = (l * Math.sqrt(2.0)) * Math.sqrt((n * (U * ((n / ((Om * Om) / (U_42_ - U))) - (2.0 / Om)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om))))) tmp = 0 if l <= 4.5e+78: tmp = t_1 elif l <= 3.6e+130: tmp = math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))) elif l <= 2.4e+145: tmp = t_1 else: tmp = (l * math.sqrt(2.0)) * math.sqrt((n * (U * ((n / ((Om * Om) / (U_42_ - U))) - (2.0 / Om))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l * Float64(Float64(Float64(n * Float64(l * U_42_)) / Om) + Float64(l * -2.0))) / Om))))) tmp = 0.0 if (l <= 4.5e+78) tmp = t_1; elseif (l <= 3.6e+130) tmp = sqrt(Float64(Float64(-2.0 * Float64(Float64(l * l) * Float64(n / Om))) * Float64(U * Float64(2.0 - Float64(Float64(n * U_42_) / Om))))); elseif (l <= 2.4e+145) tmp = t_1; else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(n * Float64(U * Float64(Float64(n / Float64(Float64(Om * Om) / Float64(U_42_ - U))) - Float64(2.0 / Om)))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om))))); tmp = 0.0; if (l <= 4.5e+78) tmp = t_1; elseif (l <= 3.6e+130) tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))); elseif (l <= 2.4e+145) tmp = t_1; else tmp = (l * sqrt(2.0)) * sqrt((n * (U * ((n / ((Om * Om) / (U_42_ - U))) - (2.0 / Om))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l * N[(N[(N[(n * N[(l * U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] + N[(l * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, 4.5e+78], t$95$1, If[LessEqual[l, 3.6e+130], N[Sqrt[N[(N[(-2.0 * N[(N[(l * l), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U * N[(2.0 - N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 2.4e+145], t$95$1, N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(n * N[(U * N[(N[(n / N[(N[(Om * Om), $MachinePrecision] / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{\ell \cdot \left(\frac{n \cdot \left(\ell \cdot U*\right)}{Om} + \ell \cdot -2\right)}{Om}\right)\right)}\\
\mathbf{if}\;\ell \leq 4.5 \cdot 10^{+78}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq 3.6 \cdot 10^{+130}:\\
\;\;\;\;\sqrt{\left(-2 \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{n}{Om}\right)\right) \cdot \left(U \cdot \left(2 - \frac{n \cdot U*}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.4 \cdot 10^{+145}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{n \cdot \left(U \cdot \left(\frac{n}{\frac{Om \cdot Om}{U* - U}} - \frac{2}{Om}\right)\right)}\\
\end{array}
\end{array}
if l < 4.4999999999999999e78 or 3.6000000000000001e130 < l < 2.39999999999999992e145Initial program 54.5%
Simplified61.2%
Taylor expanded in U around 0 60.1%
if 4.4999999999999999e78 < l < 3.6000000000000001e130Initial program 41.0%
Simplified36.6%
Taylor expanded in l around -inf 68.2%
associate-/l*36.6%
associate-/r*37.0%
unpow237.0%
*-commutative37.0%
mul-1-neg37.0%
unsub-neg37.0%
associate-/l*37.0%
Simplified37.0%
*-un-lft-identity37.0%
associate-/r/37.0%
associate-/r/37.0%
Applied egg-rr37.0%
*-lft-identity37.0%
associate-*r*37.7%
unpow237.7%
associate-/r/62.8%
unpow262.8%
associate-*l/62.8%
associate-*l/62.8%
*-commutative62.8%
Simplified62.8%
Taylor expanded in U* around inf 62.8%
if 2.39999999999999992e145 < l Initial program 9.3%
Simplified45.5%
Taylor expanded in l around inf 69.6%
associate-/l*70.4%
unpow270.4%
associate-*r/70.4%
metadata-eval70.4%
Simplified70.4%
Final simplification61.2%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= U 0.005)
(sqrt
(*
(* 2.0 n)
(* U (+ t (* (/ l Om) (fma l -2.0 (* (/ l Om) (* n (- U* U)))))))))
(sqrt (* (* (* 2.0 n) U) (+ t (* -2.0 (* l (/ l Om))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 0.005) {
tmp = sqrt(((2.0 * n) * (U * (t + ((l / Om) * fma(l, -2.0, ((l / Om) * (n * (U_42_ - U)))))))));
} else {
tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om))))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U <= 0.005) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l / Om) * fma(l, -2.0, Float64(Float64(l / Om) * Float64(n * Float64(U_42_ - U))))))))); else tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(t + Float64(-2.0 * Float64(l * Float64(l / Om)))))); end return tmp end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U, 0.005], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l / Om), $MachinePrecision] * N[(l * -2.0 + N[(N[(l / Om), $MachinePrecision] * N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U \leq 0.005:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{\ell}{Om} \cdot \mathsf{fma}\left(\ell, -2, \frac{\ell}{Om} \cdot \left(n \cdot \left(U* - U\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(t + -2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right)}\\
\end{array}
\end{array}
if U < 0.0050000000000000001Initial program 47.0%
Simplified62.5%
if 0.0050000000000000001 < U Initial program 59.7%
Taylor expanded in Om around inf 54.4%
unpow254.4%
associate-*r/59.9%
Simplified59.9%
Final simplification61.9%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (sqrt (* (* (* 2.0 n) U) (+ t (* -2.0 (* l (/ l Om))))))))
(if (<= l 1.12e-157)
(sqrt (* (* 2.0 n) (* U t)))
(if (<= l 1.25e+32)
(sqrt (* (* 2.0 n) (* U (+ t (* (/ (* n (* l l)) Om) (/ U* Om))))))
(if (<= l 6.2e+65)
t_1
(if (<= l 9.2e+170)
(sqrt
(* (* -2.0 (* (* l l) (/ n Om))) (* U (- 2.0 (/ (* n U*) Om)))))
(if (<= l 3.8e+233)
t_1
(sqrt
(*
-2.0
(/
n
(/
(/ (/ Om l) l)
(* U (- 2.0 (/ n (/ Om (- U* U))))))))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om))))));
double tmp;
if (l <= 1.12e-157) {
tmp = sqrt(((2.0 * n) * (U * t)));
} else if (l <= 1.25e+32) {
tmp = sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om))))));
} else if (l <= 6.2e+65) {
tmp = t_1;
} else if (l <= 9.2e+170) {
tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else if (l <= 3.8e+233) {
tmp = t_1;
} else {
tmp = sqrt((-2.0 * (n / (((Om / l) / l) / (U * (2.0 - (n / (Om / (U_42_ - U)))))))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt((((2.0d0 * n) * u) * (t + ((-2.0d0) * (l * (l / om))))))
if (l <= 1.12d-157) then
tmp = sqrt(((2.0d0 * n) * (u * t)))
else if (l <= 1.25d+32) then
tmp = sqrt(((2.0d0 * n) * (u * (t + (((n * (l * l)) / om) * (u_42 / om))))))
else if (l <= 6.2d+65) then
tmp = t_1
else if (l <= 9.2d+170) then
tmp = sqrt((((-2.0d0) * ((l * l) * (n / om))) * (u * (2.0d0 - ((n * u_42) / om)))))
else if (l <= 3.8d+233) then
tmp = t_1
else
tmp = sqrt(((-2.0d0) * (n / (((om / l) / l) / (u * (2.0d0 - (n / (om / (u_42 - u)))))))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om))))));
double tmp;
if (l <= 1.12e-157) {
tmp = Math.sqrt(((2.0 * n) * (U * t)));
} else if (l <= 1.25e+32) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om))))));
} else if (l <= 6.2e+65) {
tmp = t_1;
} else if (l <= 9.2e+170) {
tmp = Math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else if (l <= 3.8e+233) {
tmp = t_1;
} else {
tmp = Math.sqrt((-2.0 * (n / (((Om / l) / l) / (U * (2.0 - (n / (Om / (U_42_ - U)))))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om)))))) tmp = 0 if l <= 1.12e-157: tmp = math.sqrt(((2.0 * n) * (U * t))) elif l <= 1.25e+32: tmp = math.sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om)))))) elif l <= 6.2e+65: tmp = t_1 elif l <= 9.2e+170: tmp = math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))) elif l <= 3.8e+233: tmp = t_1 else: tmp = math.sqrt((-2.0 * (n / (((Om / l) / l) / (U * (2.0 - (n / (Om / (U_42_ - U))))))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(t + Float64(-2.0 * Float64(l * Float64(l / Om)))))) tmp = 0.0 if (l <= 1.12e-157) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * t))); elseif (l <= 1.25e+32) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(Float64(n * Float64(l * l)) / Om) * Float64(U_42_ / Om)))))); elseif (l <= 6.2e+65) tmp = t_1; elseif (l <= 9.2e+170) tmp = sqrt(Float64(Float64(-2.0 * Float64(Float64(l * l) * Float64(n / Om))) * Float64(U * Float64(2.0 - Float64(Float64(n * U_42_) / Om))))); elseif (l <= 3.8e+233) tmp = t_1; else tmp = sqrt(Float64(-2.0 * Float64(n / Float64(Float64(Float64(Om / l) / l) / Float64(U * Float64(2.0 - Float64(n / Float64(Om / Float64(U_42_ - U))))))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om)))))); tmp = 0.0; if (l <= 1.12e-157) tmp = sqrt(((2.0 * n) * (U * t))); elseif (l <= 1.25e+32) tmp = sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om)))))); elseif (l <= 6.2e+65) tmp = t_1; elseif (l <= 9.2e+170) tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))); elseif (l <= 3.8e+233) tmp = t_1; else tmp = sqrt((-2.0 * (n / (((Om / l) / l) / (U * (2.0 - (n / (Om / (U_42_ - U))))))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, 1.12e-157], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 1.25e+32], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] * N[(U$42$ / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 6.2e+65], t$95$1, If[LessEqual[l, 9.2e+170], N[Sqrt[N[(N[(-2.0 * N[(N[(l * l), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U * N[(2.0 - N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.8e+233], t$95$1, N[Sqrt[N[(-2.0 * N[(n / N[(N[(N[(Om / l), $MachinePrecision] / l), $MachinePrecision] / N[(U * N[(2.0 - N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(t + -2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right)}\\
\mathbf{if}\;\ell \leq 1.12 \cdot 10^{-157}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot t\right)}\\
\mathbf{elif}\;\ell \leq 1.25 \cdot 10^{+32}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{n \cdot \left(\ell \cdot \ell\right)}{Om} \cdot \frac{U*}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 6.2 \cdot 10^{+65}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq 9.2 \cdot 10^{+170}:\\
\;\;\;\;\sqrt{\left(-2 \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{n}{Om}\right)\right) \cdot \left(U \cdot \left(2 - \frac{n \cdot U*}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.8 \cdot 10^{+233}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\sqrt{-2 \cdot \frac{n}{\frac{\frac{\frac{Om}{\ell}}{\ell}}{U \cdot \left(2 - \frac{n}{\frac{Om}{U* - U}}\right)}}}\\
\end{array}
\end{array}
if l < 1.12000000000000001e-157Initial program 55.1%
Simplified64.3%
Taylor expanded in t around inf 40.0%
if 1.12000000000000001e-157 < l < 1.2499999999999999e32Initial program 46.9%
associate-*l*53.5%
sub-neg53.5%
associate-+l-53.5%
sub-neg53.5%
associate-/l*53.5%
remove-double-neg53.5%
associate-*l*50.8%
Simplified50.8%
Taylor expanded in U* around inf 48.2%
mul-1-neg48.2%
associate-/l*45.5%
distribute-neg-frac45.5%
*-commutative45.5%
associate-/r*45.6%
unpow245.6%
unpow245.6%
Simplified45.6%
Taylor expanded in U around 0 48.2%
associate-*r*48.2%
*-commutative48.2%
sub-neg48.2%
mul-1-neg48.2%
remove-double-neg48.2%
associate-*r*48.2%
unpow248.2%
times-frac50.9%
unpow250.9%
Simplified50.9%
if 1.2499999999999999e32 < l < 6.19999999999999981e65 or 9.2000000000000003e170 < l < 3.7999999999999999e233Initial program 29.8%
Taylor expanded in Om around inf 30.4%
unpow230.4%
associate-*r/57.1%
Simplified57.1%
if 6.19999999999999981e65 < l < 9.2000000000000003e170Initial program 37.5%
Simplified43.0%
Taylor expanded in l around -inf 62.1%
associate-/l*43.1%
associate-/r*43.2%
unpow243.2%
*-commutative43.2%
mul-1-neg43.2%
unsub-neg43.2%
associate-/l*43.2%
Simplified43.2%
*-un-lft-identity43.2%
associate-/r/49.6%
associate-/r/49.6%
Applied egg-rr49.6%
*-lft-identity49.6%
associate-*r*49.9%
unpow249.9%
associate-/r/59.9%
unpow259.9%
associate-*l/59.9%
associate-*l/59.9%
*-commutative59.9%
Simplified59.9%
Taylor expanded in U* around inf 59.9%
if 3.7999999999999999e233 < l Initial program 14.2%
Simplified53.8%
Taylor expanded in l around -inf 53.8%
associate-/l*53.8%
associate-/r*53.8%
unpow253.8%
*-commutative53.8%
mul-1-neg53.8%
unsub-neg53.8%
associate-/l*53.8%
Simplified53.8%
Taylor expanded in Om around 0 53.8%
unpow253.8%
associate-/r*53.8%
Simplified53.8%
Final simplification44.5%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= Om -1.34e+125)
(sqrt (* (* (* 2.0 n) U) (+ t (* -2.0 (* l (/ l Om))))))
(if (<= Om 5.6e+197)
(sqrt
(*
(* 2.0 n)
(* U (+ t (/ (* l (+ (/ (* n (* l U*)) Om) (* l -2.0))) Om)))))
(sqrt
(*
(* 2.0 n)
(* U (+ t (/ l (/ Om (- (* l -2.0) (/ n (/ Om (* U l)))))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= -1.34e+125) {
tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om))))));
} else if (Om <= 5.6e+197) {
tmp = sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om)))));
} else {
tmp = sqrt(((2.0 * n) * (U * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l))))))))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (om <= (-1.34d+125)) then
tmp = sqrt((((2.0d0 * n) * u) * (t + ((-2.0d0) * (l * (l / om))))))
else if (om <= 5.6d+197) then
tmp = sqrt(((2.0d0 * n) * (u * (t + ((l * (((n * (l * u_42)) / om) + (l * (-2.0d0)))) / om)))))
else
tmp = sqrt(((2.0d0 * n) * (u * (t + (l / (om / ((l * (-2.0d0)) - (n / (om / (u * l))))))))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= -1.34e+125) {
tmp = Math.sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om))))));
} else if (Om <= 5.6e+197) {
tmp = Math.sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om)))));
} else {
tmp = Math.sqrt(((2.0 * n) * (U * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l))))))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if Om <= -1.34e+125: tmp = math.sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om)))))) elif Om <= 5.6e+197: tmp = math.sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om))))) else: tmp = math.sqrt(((2.0 * n) * (U * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l)))))))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (Om <= -1.34e+125) tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(t + Float64(-2.0 * Float64(l * Float64(l / Om)))))); elseif (Om <= 5.6e+197) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(l * Float64(Float64(Float64(n * Float64(l * U_42_)) / Om) + Float64(l * -2.0))) / Om))))); else tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(l / Float64(Om / Float64(Float64(l * -2.0) - Float64(n / Float64(Om / Float64(U * l)))))))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (Om <= -1.34e+125) tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * (l * (l / Om)))))); elseif (Om <= 5.6e+197) tmp = sqrt(((2.0 * n) * (U * (t + ((l * (((n * (l * U_42_)) / Om) + (l * -2.0))) / Om))))); else tmp = sqrt(((2.0 * n) * (U * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l)))))))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[Om, -1.34e+125], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, 5.6e+197], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(l * N[(N[(N[(n * N[(l * U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] + N[(l * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(l / N[(Om / N[(N[(l * -2.0), $MachinePrecision] - N[(n / N[(Om / N[(U * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -1.34 \cdot 10^{+125}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(t + -2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right)}\\
\mathbf{elif}\;Om \leq 5.6 \cdot 10^{+197}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{\ell \cdot \left(\frac{n \cdot \left(\ell \cdot U*\right)}{Om} + \ell \cdot -2\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{\ell}{\frac{Om}{\ell \cdot -2 - \frac{n}{\frac{Om}{U \cdot \ell}}}}\right)\right)}\\
\end{array}
\end{array}
if Om < -1.3399999999999999e125Initial program 42.5%
Taylor expanded in Om around inf 42.5%
unpow242.5%
associate-*r/63.4%
Simplified63.4%
if -1.3399999999999999e125 < Om < 5.5999999999999997e197Initial program 52.2%
Simplified60.8%
Taylor expanded in U around 0 61.0%
if 5.5999999999999997e197 < Om Initial program 43.1%
Simplified49.5%
Taylor expanded in U* around 0 56.2%
*-commutative56.2%
+-commutative56.2%
associate-/l*62.8%
+-commutative62.8%
mul-1-neg62.8%
unsub-neg62.8%
*-commutative62.8%
associate-/l*66.2%
Simplified66.2%
Final simplification62.0%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (/ l Om)))
(t_2
(sqrt (* (* 2.0 n) (* U (+ t (* (/ (* n (* l l)) Om) (/ U* Om))))))))
(if (<= n -1.12e-57)
t_2
(if (<= n -2.35e-283)
(sqrt (* (* 2.0 n) (* U (- t (* 2.0 t_1)))))
(if (<= n 7e-59) (sqrt (* (* (* 2.0 n) U) (+ t (* -2.0 t_1)))) t_2)))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double t_2 = sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om))))));
double tmp;
if (n <= -1.12e-57) {
tmp = t_2;
} else if (n <= -2.35e-283) {
tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
} else if (n <= 7e-59) {
tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
} else {
tmp = t_2;
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = l * (l / om)
t_2 = sqrt(((2.0d0 * n) * (u * (t + (((n * (l * l)) / om) * (u_42 / om))))))
if (n <= (-1.12d-57)) then
tmp = t_2
else if (n <= (-2.35d-283)) then
tmp = sqrt(((2.0d0 * n) * (u * (t - (2.0d0 * t_1)))))
else if (n <= 7d-59) then
tmp = sqrt((((2.0d0 * n) * u) * (t + ((-2.0d0) * t_1))))
else
tmp = t_2
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double t_2 = Math.sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om))))));
double tmp;
if (n <= -1.12e-57) {
tmp = t_2;
} else if (n <= -2.35e-283) {
tmp = Math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
} else if (n <= 7e-59) {
tmp = Math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
} else {
tmp = t_2;
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = l * (l / Om) t_2 = math.sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om)))))) tmp = 0 if n <= -1.12e-57: tmp = t_2 elif n <= -2.35e-283: tmp = math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))) elif n <= 7e-59: tmp = math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))) else: tmp = t_2 return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * Float64(l / Om)) t_2 = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t + Float64(Float64(Float64(n * Float64(l * l)) / Om) * Float64(U_42_ / Om)))))) tmp = 0.0 if (n <= -1.12e-57) tmp = t_2; elseif (n <= -2.35e-283) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t - Float64(2.0 * t_1))))); elseif (n <= 7e-59) tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(t + Float64(-2.0 * t_1)))); else tmp = t_2; end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = l * (l / Om); t_2 = sqrt(((2.0 * n) * (U * (t + (((n * (l * l)) / Om) * (U_42_ / Om)))))); tmp = 0.0; if (n <= -1.12e-57) tmp = t_2; elseif (n <= -2.35e-283) tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))); elseif (n <= 7e-59) tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))); else tmp = t_2; end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t + N[(N[(N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] * N[(U$42$ / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[n, -1.12e-57], t$95$2, If[LessEqual[n, -2.35e-283], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t - N[(2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[n, 7e-59], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(t + N[(-2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \frac{\ell}{Om}\\
t_2 := \sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t + \frac{n \cdot \left(\ell \cdot \ell\right)}{Om} \cdot \frac{U*}{Om}\right)\right)}\\
\mathbf{if}\;n \leq -1.12 \cdot 10^{-57}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;n \leq -2.35 \cdot 10^{-283}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t - 2 \cdot t_1\right)\right)}\\
\mathbf{elif}\;n \leq 7 \cdot 10^{-59}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(t + -2 \cdot t_1\right)}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if n < -1.12e-57 or 7.0000000000000002e-59 < n Initial program 55.0%
associate-*l*57.4%
sub-neg57.4%
associate-+l-57.4%
sub-neg57.4%
associate-/l*60.9%
remove-double-neg60.9%
associate-*l*61.6%
Simplified61.6%
Taylor expanded in U* around inf 52.2%
mul-1-neg52.2%
associate-/l*53.0%
distribute-neg-frac53.0%
*-commutative53.0%
associate-/r*53.7%
unpow253.7%
unpow253.7%
Simplified53.7%
Taylor expanded in U around 0 52.2%
associate-*r*52.2%
*-commutative52.2%
sub-neg52.2%
mul-1-neg52.2%
remove-double-neg52.2%
associate-*r*52.2%
unpow252.2%
times-frac58.2%
unpow258.2%
Simplified58.2%
if -1.12e-57 < n < -2.3499999999999999e-283Initial program 39.7%
associate-*l*55.2%
sub-neg55.2%
associate-+l-55.2%
sub-neg55.2%
associate-/l*60.2%
remove-double-neg60.2%
associate-*l*55.2%
Simplified55.2%
Taylor expanded in Om around inf 53.6%
unpow253.6%
associate-*r/58.6%
Simplified58.6%
if -2.3499999999999999e-283 < n < 7.0000000000000002e-59Initial program 46.6%
Taylor expanded in Om around inf 43.5%
unpow243.5%
associate-*r/50.1%
Simplified50.1%
Final simplification56.5%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (/ l Om))))
(if (<= Om -8e-172)
(sqrt (* (* (* 2.0 n) U) (+ t (* -2.0 t_1))))
(if (<= Om 4.2e-215)
(sqrt (* -2.0 (* (/ n Om) (* U (* l (* l (- 2.0 (* U* (/ n Om)))))))))
(sqrt (* (* 2.0 n) (* U (- t (* 2.0 t_1)))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double tmp;
if (Om <= -8e-172) {
tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
} else if (Om <= 4.2e-215) {
tmp = sqrt((-2.0 * ((n / Om) * (U * (l * (l * (2.0 - (U_42_ * (n / Om)))))))));
} else {
tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: t_1
real(8) :: tmp
t_1 = l * (l / om)
if (om <= (-8d-172)) then
tmp = sqrt((((2.0d0 * n) * u) * (t + ((-2.0d0) * t_1))))
else if (om <= 4.2d-215) then
tmp = sqrt(((-2.0d0) * ((n / om) * (u * (l * (l * (2.0d0 - (u_42 * (n / om)))))))))
else
tmp = sqrt(((2.0d0 * n) * (u * (t - (2.0d0 * t_1)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double tmp;
if (Om <= -8e-172) {
tmp = Math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
} else if (Om <= 4.2e-215) {
tmp = Math.sqrt((-2.0 * ((n / Om) * (U * (l * (l * (2.0 - (U_42_ * (n / Om)))))))));
} else {
tmp = Math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = l * (l / Om) tmp = 0 if Om <= -8e-172: tmp = math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))) elif Om <= 4.2e-215: tmp = math.sqrt((-2.0 * ((n / Om) * (U * (l * (l * (2.0 - (U_42_ * (n / Om))))))))) else: tmp = math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * Float64(l / Om)) tmp = 0.0 if (Om <= -8e-172) tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(t + Float64(-2.0 * t_1)))); elseif (Om <= 4.2e-215) tmp = sqrt(Float64(-2.0 * Float64(Float64(n / Om) * Float64(U * Float64(l * Float64(l * Float64(2.0 - Float64(U_42_ * Float64(n / Om))))))))); else tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t - Float64(2.0 * t_1))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = l * (l / Om); tmp = 0.0; if (Om <= -8e-172) tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))); elseif (Om <= 4.2e-215) tmp = sqrt((-2.0 * ((n / Om) * (U * (l * (l * (2.0 - (U_42_ * (n / Om))))))))); else tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Om, -8e-172], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(t + N[(-2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, 4.2e-215], N[Sqrt[N[(-2.0 * N[(N[(n / Om), $MachinePrecision] * N[(U * N[(l * N[(l * N[(2.0 - N[(U$42$ * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t - N[(2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \frac{\ell}{Om}\\
\mathbf{if}\;Om \leq -8 \cdot 10^{-172}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(t + -2 \cdot t_1\right)}\\
\mathbf{elif}\;Om \leq 4.2 \cdot 10^{-215}:\\
\;\;\;\;\sqrt{-2 \cdot \left(\frac{n}{Om} \cdot \left(U \cdot \left(\ell \cdot \left(\ell \cdot \left(2 - U* \cdot \frac{n}{Om}\right)\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t - 2 \cdot t_1\right)\right)}\\
\end{array}
\end{array}
if Om < -8.0000000000000003e-172Initial program 49.0%
Taylor expanded in Om around inf 45.9%
unpow245.9%
associate-*r/54.8%
Simplified54.8%
if -8.0000000000000003e-172 < Om < 4.2e-215Initial program 49.2%
Simplified63.7%
Taylor expanded in l around -inf 58.4%
associate-/l*52.0%
associate-/r*52.0%
unpow252.0%
*-commutative52.0%
mul-1-neg52.0%
unsub-neg52.0%
associate-/l*49.4%
Simplified49.4%
*-un-lft-identity49.4%
associate-/r/49.4%
associate-/r/52.4%
Applied egg-rr52.4%
*-lft-identity52.4%
associate-*r*52.4%
unpow252.4%
associate-/r/57.0%
unpow257.0%
associate-*l/57.0%
associate-*l/57.0%
*-commutative57.0%
Simplified57.0%
Taylor expanded in U around 0 58.4%
associate-/l*52.1%
associate-/r/58.9%
associate-*r*56.6%
*-commutative56.6%
unpow256.6%
associate-*l*57.0%
associate-/l*52.2%
associate-/r/57.0%
Simplified57.0%
if 4.2e-215 < Om Initial program 50.2%
associate-*l*57.7%
sub-neg57.7%
associate-+l-57.7%
sub-neg57.7%
associate-/l*60.3%
remove-double-neg60.3%
associate-*l*59.4%
Simplified59.4%
Taylor expanded in Om around inf 49.9%
unpow249.9%
associate-*r/51.6%
Simplified51.6%
Final simplification53.7%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (/ l Om))))
(if (<= Om -1.45e-173)
(sqrt (* (* (* 2.0 n) U) (+ t (* -2.0 t_1))))
(if (<= Om 1.15e-87)
(sqrt (* (* -2.0 (* (* l l) (/ n Om))) (* U (- 2.0 (/ (* n U*) Om)))))
(sqrt (* (* 2.0 n) (* U (- t (* 2.0 t_1)))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double tmp;
if (Om <= -1.45e-173) {
tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
} else if (Om <= 1.15e-87) {
tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else {
tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: t_1
real(8) :: tmp
t_1 = l * (l / om)
if (om <= (-1.45d-173)) then
tmp = sqrt((((2.0d0 * n) * u) * (t + ((-2.0d0) * t_1))))
else if (om <= 1.15d-87) then
tmp = sqrt((((-2.0d0) * ((l * l) * (n / om))) * (u * (2.0d0 - ((n * u_42) / om)))))
else
tmp = sqrt(((2.0d0 * n) * (u * (t - (2.0d0 * t_1)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double tmp;
if (Om <= -1.45e-173) {
tmp = Math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
} else if (Om <= 1.15e-87) {
tmp = Math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om)))));
} else {
tmp = Math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = l * (l / Om) tmp = 0 if Om <= -1.45e-173: tmp = math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))) elif Om <= 1.15e-87: tmp = math.sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))) else: tmp = math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * Float64(l / Om)) tmp = 0.0 if (Om <= -1.45e-173) tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(t + Float64(-2.0 * t_1)))); elseif (Om <= 1.15e-87) tmp = sqrt(Float64(Float64(-2.0 * Float64(Float64(l * l) * Float64(n / Om))) * Float64(U * Float64(2.0 - Float64(Float64(n * U_42_) / Om))))); else tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t - Float64(2.0 * t_1))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = l * (l / Om); tmp = 0.0; if (Om <= -1.45e-173) tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))); elseif (Om <= 1.15e-87) tmp = sqrt(((-2.0 * ((l * l) * (n / Om))) * (U * (2.0 - ((n * U_42_) / Om))))); else tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Om, -1.45e-173], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(t + N[(-2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, 1.15e-87], N[Sqrt[N[(N[(-2.0 * N[(N[(l * l), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(U * N[(2.0 - N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t - N[(2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \frac{\ell}{Om}\\
\mathbf{if}\;Om \leq -1.45 \cdot 10^{-173}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(t + -2 \cdot t_1\right)}\\
\mathbf{elif}\;Om \leq 1.15 \cdot 10^{-87}:\\
\;\;\;\;\sqrt{\left(-2 \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{n}{Om}\right)\right) \cdot \left(U \cdot \left(2 - \frac{n \cdot U*}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t - 2 \cdot t_1\right)\right)}\\
\end{array}
\end{array}
if Om < -1.4499999999999999e-173Initial program 49.0%
Taylor expanded in Om around inf 45.9%
unpow245.9%
associate-*r/54.8%
Simplified54.8%
if -1.4499999999999999e-173 < Om < 1.1500000000000001e-87Initial program 47.9%
Simplified61.0%
Taylor expanded in l around -inf 52.1%
associate-/l*47.9%
associate-/r*46.4%
unpow246.4%
*-commutative46.4%
mul-1-neg46.4%
unsub-neg46.4%
associate-/l*43.0%
Simplified43.0%
*-un-lft-identity43.0%
associate-/r/43.0%
associate-/r/46.7%
Applied egg-rr46.7%
*-lft-identity46.7%
associate-*r*46.7%
unpow246.7%
associate-/r/51.2%
unpow251.2%
associate-*l/51.3%
associate-*l/51.2%
*-commutative51.2%
Simplified51.2%
Taylor expanded in U* around inf 51.3%
if 1.1500000000000001e-87 < Om Initial program 51.3%
associate-*l*58.2%
sub-neg58.2%
associate-+l-58.2%
sub-neg58.2%
associate-/l*61.4%
remove-double-neg61.4%
associate-*l*60.3%
Simplified60.3%
Taylor expanded in Om around inf 53.3%
unpow253.3%
associate-*r/55.3%
Simplified55.3%
Final simplification54.1%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= U* 2.1e+143) (sqrt (* (* 2.0 n) (* U (- t (* 2.0 (* l (/ l Om))))))) (sqrt (* -2.0 (/ n (/ (/ Om (* l l)) (/ (- n) (/ Om (* U U*)))))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U_42_ <= 2.1e+143) {
tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om)))))));
} else {
tmp = sqrt((-2.0 * (n / ((Om / (l * l)) / (-n / (Om / (U * U_42_)))))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (u_42 <= 2.1d+143) then
tmp = sqrt(((2.0d0 * n) * (u * (t - (2.0d0 * (l * (l / om)))))))
else
tmp = sqrt(((-2.0d0) * (n / ((om / (l * l)) / (-n / (om / (u * u_42)))))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U_42_ <= 2.1e+143) {
tmp = Math.sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om)))))));
} else {
tmp = Math.sqrt((-2.0 * (n / ((Om / (l * l)) / (-n / (Om / (U * U_42_)))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if U_42_ <= 2.1e+143: tmp = math.sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om))))))) else: tmp = math.sqrt((-2.0 * (n / ((Om / (l * l)) / (-n / (Om / (U * U_42_))))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U_42_ <= 2.1e+143) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t - Float64(2.0 * Float64(l * Float64(l / Om))))))); else tmp = sqrt(Float64(-2.0 * Float64(n / Float64(Float64(Om / Float64(l * l)) / Float64(Float64(-n) / Float64(Om / Float64(U * U_42_))))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U_42_ <= 2.1e+143) tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om))))))); else tmp = sqrt((-2.0 * (n / ((Om / (l * l)) / (-n / (Om / (U * U_42_))))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U$42$, 2.1e+143], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t - N[(2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(-2.0 * N[(n / N[(N[(Om / N[(l * l), $MachinePrecision]), $MachinePrecision] / N[((-n) / N[(Om / N[(U * U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U* \leq 2.1 \cdot 10^{+143}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t - 2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{-2 \cdot \frac{n}{\frac{\frac{Om}{\ell \cdot \ell}}{\frac{-n}{\frac{Om}{U \cdot U*}}}}}\\
\end{array}
\end{array}
if U* < 2.09999999999999988e143Initial program 48.4%
associate-*l*54.1%
sub-neg54.1%
associate-+l-54.1%
sub-neg54.1%
associate-/l*59.0%
remove-double-neg59.0%
associate-*l*58.0%
Simplified58.0%
Taylor expanded in Om around inf 47.9%
unpow247.9%
associate-*r/52.3%
Simplified52.3%
if 2.09999999999999988e143 < U* Initial program 54.4%
Simplified55.2%
Taylor expanded in l around -inf 41.5%
associate-/l*41.5%
associate-/r*42.8%
unpow242.8%
*-commutative42.8%
mul-1-neg42.8%
unsub-neg42.8%
associate-/l*44.5%
Simplified44.5%
Taylor expanded in U* around inf 42.8%
mul-1-neg42.8%
associate-/l*44.5%
distribute-neg-frac44.5%
Simplified44.5%
Final simplification50.7%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= U 1.12e+48) (sqrt (* (* 2.0 n) (* U (- t (* 2.0 (* l (/ l Om))))))) (pow (* 2.0 (* t (* n U))) 0.5)))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 1.12e+48) {
tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om)))))));
} else {
tmp = pow((2.0 * (t * (n * U))), 0.5);
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (u <= 1.12d+48) then
tmp = sqrt(((2.0d0 * n) * (u * (t - (2.0d0 * (l * (l / om)))))))
else
tmp = (2.0d0 * (t * (n * u))) ** 0.5d0
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 1.12e+48) {
tmp = Math.sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om)))))));
} else {
tmp = Math.pow((2.0 * (t * (n * U))), 0.5);
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if U <= 1.12e+48: tmp = math.sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om))))))) else: tmp = math.pow((2.0 * (t * (n * U))), 0.5) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U <= 1.12e+48) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t - Float64(2.0 * Float64(l * Float64(l / Om))))))); else tmp = Float64(2.0 * Float64(t * Float64(n * U))) ^ 0.5; end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U <= 1.12e+48) tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * (l * (l / Om))))))); else tmp = (2.0 * (t * (n * U))) ^ 0.5; end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U, 1.12e+48], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t - N[(2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Power[N[(2.0 * N[(t * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U \leq 1.12 \cdot 10^{+48}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t - 2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(2 \cdot \left(t \cdot \left(n \cdot U\right)\right)\right)}^{0.5}\\
\end{array}
\end{array}
if U < 1.11999999999999995e48Initial program 47.0%
associate-*l*54.2%
sub-neg54.2%
associate-+l-54.2%
sub-neg54.2%
associate-/l*59.4%
remove-double-neg59.4%
associate-*l*58.5%
Simplified58.5%
Taylor expanded in Om around inf 45.0%
unpow245.0%
associate-*r/49.2%
Simplified49.2%
if 1.11999999999999995e48 < U Initial program 63.0%
Simplified45.4%
Taylor expanded in t around inf 31.2%
pow1/233.9%
associate-*l*33.9%
*-commutative33.9%
associate-*r*54.6%
Applied egg-rr54.6%
Final simplification50.1%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (/ l Om))))
(if (<= U 3.5e-143)
(sqrt (* (* 2.0 n) (* U (- t (* 2.0 t_1)))))
(sqrt (* (* (* 2.0 n) U) (+ t (* -2.0 t_1)))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double tmp;
if (U <= 3.5e-143) {
tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
} else {
tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: t_1
real(8) :: tmp
t_1 = l * (l / om)
if (u <= 3.5d-143) then
tmp = sqrt(((2.0d0 * n) * (u * (t - (2.0d0 * t_1)))))
else
tmp = sqrt((((2.0d0 * n) * u) * (t + ((-2.0d0) * t_1))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double tmp;
if (U <= 3.5e-143) {
tmp = Math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1)))));
} else {
tmp = Math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = l * (l / Om) tmp = 0 if U <= 3.5e-143: tmp = math.sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))) else: tmp = math.sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * Float64(l / Om)) tmp = 0.0 if (U <= 3.5e-143) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * Float64(t - Float64(2.0 * t_1))))); else tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(t + Float64(-2.0 * t_1)))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = l * (l / Om); tmp = 0.0; if (U <= 3.5e-143) tmp = sqrt(((2.0 * n) * (U * (t - (2.0 * t_1))))); else tmp = sqrt((((2.0 * n) * U) * (t + (-2.0 * t_1)))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[U, 3.5e-143], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * N[(t - N[(2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(t + N[(-2.0 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \frac{\ell}{Om}\\
\mathbf{if}\;U \leq 3.5 \cdot 10^{-143}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot \left(t - 2 \cdot t_1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(t + -2 \cdot t_1\right)}\\
\end{array}
\end{array}
if U < 3.50000000000000005e-143Initial program 45.8%
associate-*l*55.2%
sub-neg55.2%
associate-+l-55.2%
sub-neg55.2%
associate-/l*59.0%
remove-double-neg59.0%
associate-*l*58.4%
Simplified58.4%
Taylor expanded in Om around inf 46.1%
unpow246.1%
associate-*r/49.2%
Simplified49.2%
if 3.50000000000000005e-143 < U Initial program 56.5%
Taylor expanded in Om around inf 48.1%
unpow248.1%
associate-*r/54.4%
Simplified54.4%
Final simplification51.1%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 2.25e+24) (pow (* 2.0 (* n (* U t))) 0.5) (sqrt (* -4.0 (* U (* (* l l) (/ n Om)))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 2.25e+24) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = sqrt((-4.0 * (U * ((l * l) * (n / Om)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (l <= 2.25d+24) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else
tmp = sqrt(((-4.0d0) * (u * ((l * l) * (n / om)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 2.25e+24) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = Math.sqrt((-4.0 * (U * ((l * l) * (n / Om)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 2.25e+24: tmp = math.pow((2.0 * (n * (U * t))), 0.5) else: tmp = math.sqrt((-4.0 * (U * ((l * l) * (n / Om))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 2.25e+24) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; else tmp = sqrt(Float64(-4.0 * Float64(U * Float64(Float64(l * l) * Float64(n / Om))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 2.25e+24) tmp = (2.0 * (n * (U * t))) ^ 0.5; else tmp = sqrt((-4.0 * (U * ((l * l) * (n / Om))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 2.25e+24], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(-4.0 * N[(U * N[(N[(l * l), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 2.25 \cdot 10^{+24}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{-4 \cdot \left(U \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{n}{Om}\right)\right)}\\
\end{array}
\end{array}
if l < 2.2500000000000001e24Initial program 53.5%
Taylor expanded in t around inf 33.9%
pow1/236.3%
associate-*l*39.8%
associate-*r*39.8%
Applied egg-rr39.8%
if 2.2500000000000001e24 < l Initial program 31.2%
Simplified47.2%
Taylor expanded in l around -inf 39.2%
associate-/l*32.9%
associate-/r*32.9%
unpow232.9%
*-commutative32.9%
mul-1-neg32.9%
unsub-neg32.9%
associate-/l*33.1%
Simplified33.1%
*-un-lft-identity33.1%
associate-/r/35.1%
associate-/r/35.1%
Applied egg-rr35.1%
*-lft-identity35.1%
associate-*r*35.2%
unpow235.2%
associate-/r/37.8%
unpow237.8%
associate-*l/37.8%
associate-*l/37.8%
*-commutative37.8%
Simplified37.8%
Taylor expanded in n around 0 22.7%
associate-*r*22.7%
associate-*l/22.8%
associate-*l/21.4%
unpow221.4%
*-commutative21.4%
unpow221.4%
*-commutative21.4%
unpow221.4%
Simplified21.4%
Final simplification36.5%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 5.2e+21) (pow (* 2.0 (* n (* U t))) 0.5) (sqrt (/ (* -4.0 (* n (* U (* l l)))) Om))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 5.2e+21) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = sqrt(((-4.0 * (n * (U * (l * l)))) / Om));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (l <= 5.2d+21) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else
tmp = sqrt((((-4.0d0) * (n * (u * (l * l)))) / om))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 5.2e+21) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = Math.sqrt(((-4.0 * (n * (U * (l * l)))) / Om));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 5.2e+21: tmp = math.pow((2.0 * (n * (U * t))), 0.5) else: tmp = math.sqrt(((-4.0 * (n * (U * (l * l)))) / Om)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 5.2e+21) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; else tmp = sqrt(Float64(Float64(-4.0 * Float64(n * Float64(U * Float64(l * l)))) / Om)); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 5.2e+21) tmp = (2.0 * (n * (U * t))) ^ 0.5; else tmp = sqrt(((-4.0 * (n * (U * (l * l)))) / Om)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 5.2e+21], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(N[(-4.0 * N[(n * N[(U * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 5.2 \cdot 10^{+21}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{-4 \cdot \left(n \cdot \left(U \cdot \left(\ell \cdot \ell\right)\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 5.2e21Initial program 53.5%
Taylor expanded in t around inf 33.9%
pow1/236.3%
associate-*l*39.8%
associate-*r*39.8%
Applied egg-rr39.8%
if 5.2e21 < l Initial program 31.2%
Simplified47.2%
Taylor expanded in l around -inf 39.2%
associate-/l*32.9%
associate-/r*32.9%
unpow232.9%
*-commutative32.9%
mul-1-neg32.9%
unsub-neg32.9%
associate-/l*33.1%
Simplified33.1%
*-un-lft-identity33.1%
associate-/r/35.1%
associate-/r/35.1%
Applied egg-rr35.1%
*-lft-identity35.1%
associate-*r*35.2%
unpow235.2%
associate-/r/37.8%
unpow237.8%
associate-*l/37.8%
associate-*l/37.8%
*-commutative37.8%
Simplified37.8%
Taylor expanded in n around 0 22.7%
associate-*r/23.0%
*-commutative23.0%
unpow223.0%
Simplified23.0%
Final simplification36.8%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= U 1.5e+49) (pow (* 2.0 (* n (* U t))) 0.5) (sqrt (* (* (* 2.0 n) U) t))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 1.5e+49) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = sqrt((((2.0 * n) * U) * t));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (u <= 1.5d+49) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else
tmp = sqrt((((2.0d0 * n) * u) * t))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 1.5e+49) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = Math.sqrt((((2.0 * n) * U) * t));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if U <= 1.5e+49: tmp = math.pow((2.0 * (n * (U * t))), 0.5) else: tmp = math.sqrt((((2.0 * n) * U) * t)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U <= 1.5e+49) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; else tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * t)); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U <= 1.5e+49) tmp = (2.0 * (n * (U * t))) ^ 0.5; else tmp = sqrt((((2.0 * n) * U) * t)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U, 1.5e+49], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * t), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U \leq 1.5 \cdot 10^{+49}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot t}\\
\end{array}
\end{array}
if U < 1.5000000000000001e49Initial program 47.2%
Taylor expanded in t around inf 27.8%
pow1/229.2%
associate-*l*35.9%
associate-*r*35.9%
Applied egg-rr35.9%
if 1.5000000000000001e49 < U Initial program 62.1%
Taylor expanded in t around inf 48.3%
Final simplification37.9%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= U 4.6e-144) (pow (* 2.0 (* n (* U t))) 0.5) (pow (* 2.0 (* t (* n U))) 0.5)))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 4.6e-144) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = pow((2.0 * (t * (n * U))), 0.5);
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (u <= 4.6d-144) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else
tmp = (2.0d0 * (t * (n * u))) ** 0.5d0
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 4.6e-144) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = Math.pow((2.0 * (t * (n * U))), 0.5);
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if U <= 4.6e-144: tmp = math.pow((2.0 * (n * (U * t))), 0.5) else: tmp = math.pow((2.0 * (t * (n * U))), 0.5) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U <= 4.6e-144) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; else tmp = Float64(2.0 * Float64(t * Float64(n * U))) ^ 0.5; end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U <= 4.6e-144) tmp = (2.0 * (n * (U * t))) ^ 0.5; else tmp = (2.0 * (t * (n * U))) ^ 0.5; end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U, 4.6e-144], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Power[N[(2.0 * N[(t * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U \leq 4.6 \cdot 10^{-144}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;{\left(2 \cdot \left(t \cdot \left(n \cdot U\right)\right)\right)}^{0.5}\\
\end{array}
\end{array}
if U < 4.6e-144Initial program 45.8%
Taylor expanded in t around inf 27.2%
pow1/228.4%
associate-*l*37.1%
associate-*r*37.1%
Applied egg-rr37.1%
if 4.6e-144 < U Initial program 56.5%
Simplified53.6%
Taylor expanded in t around inf 30.7%
pow1/232.0%
associate-*l*32.0%
*-commutative32.0%
associate-*r*41.6%
Applied egg-rr41.6%
Final simplification38.7%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= U 3.5e-143) (sqrt (* (* 2.0 n) (* U t))) (sqrt (* (* (* 2.0 n) U) t))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 3.5e-143) {
tmp = sqrt(((2.0 * n) * (U * t)));
} else {
tmp = sqrt((((2.0 * n) * U) * t));
}
return tmp;
}
NOTE: l should be positive before calling this function
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
real(8) :: tmp
if (u <= 3.5d-143) then
tmp = sqrt(((2.0d0 * n) * (u * t)))
else
tmp = sqrt((((2.0d0 * n) * u) * t))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= 3.5e-143) {
tmp = Math.sqrt(((2.0 * n) * (U * t)));
} else {
tmp = Math.sqrt((((2.0 * n) * U) * t));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if U <= 3.5e-143: tmp = math.sqrt(((2.0 * n) * (U * t))) else: tmp = math.sqrt((((2.0 * n) * U) * t)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U <= 3.5e-143) tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * t))); else tmp = sqrt(Float64(Float64(Float64(2.0 * n) * U) * t)); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U <= 3.5e-143) tmp = sqrt(((2.0 * n) * (U * t))); else tmp = sqrt((((2.0 * n) * U) * t)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U, 3.5e-143], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * t), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U \leq 3.5 \cdot 10^{-143}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot t}\\
\end{array}
\end{array}
if U < 3.50000000000000005e-143Initial program 45.8%
Simplified62.0%
Taylor expanded in t around inf 35.8%
if 3.50000000000000005e-143 < U Initial program 56.5%
Taylor expanded in t around inf 38.2%
Final simplification36.7%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (sqrt (* (* 2.0 n) (* U t))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt(((2.0 * n) * (U * t)));
}
NOTE: l should be positive before calling this function
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)))
end function
l = Math.abs(l);
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)));
}
l = abs(l) def code(n, U, t, l, Om, U_42_): return math.sqrt(((2.0 * n) * (U * t)))
l = abs(l) function code(n, U, t, l, Om, U_42_) return sqrt(Float64(Float64(2.0 * n) * Float64(U * t))) end
l = abs(l) function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt(((2.0 * n) * (U * t))); end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot t\right)}
\end{array}
Initial program 49.6%
Simplified59.0%
Taylor expanded in t around inf 34.0%
Final simplification34.0%
herbie shell --seed 2023242
(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*))))))