
(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 21 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}
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (+ t (* (/ l Om) (fma l -2.0 (* (* n (/ l Om)) (- U* U)))))))
(if (<= n -1.45e-117)
(sqrt (* 2.0 (* (* n U) t_1)))
(if (<= n -1.5e-230)
(sqrt
(*
(* n 2.0)
(* U (+ t (* (/ l Om) (fma l -2.0 (* (/ l Om) (* n (- U* U)))))))))
(if (<= n -1e-309)
(sqrt
(*
2.0
(* U (* n (+ t (/ l (/ Om (- (* l -2.0) (/ (* U (* n l)) Om)))))))))
(* (sqrt (* n 2.0)) (sqrt (* U t_1))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = t + ((l / Om) * fma(l, -2.0, ((n * (l / Om)) * (U_42_ - U))));
double tmp;
if (n <= -1.45e-117) {
tmp = sqrt((2.0 * ((n * U) * t_1)));
} else if (n <= -1.5e-230) {
tmp = sqrt(((n * 2.0) * (U * (t + ((l / Om) * fma(l, -2.0, ((l / Om) * (n * (U_42_ - U)))))))));
} else if (n <= -1e-309) {
tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
} else {
tmp = sqrt((n * 2.0)) * sqrt((U * t_1));
}
return tmp;
}
function code(n, U, t, l, Om, U_42_) t_1 = Float64(t + Float64(Float64(l / Om) * fma(l, -2.0, Float64(Float64(n * Float64(l / Om)) * Float64(U_42_ - U))))) tmp = 0.0 if (n <= -1.45e-117) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * t_1))); elseif (n <= -1.5e-230) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(U * Float64(t + Float64(Float64(l / Om) * fma(l, -2.0, Float64(Float64(l / Om) * Float64(n * Float64(U_42_ - U))))))))); elseif (n <= -1e-309) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(t + Float64(l / Float64(Om / Float64(Float64(l * -2.0) - Float64(Float64(U * Float64(n * l)) / Om))))))))); else tmp = Float64(sqrt(Float64(n * 2.0)) * sqrt(Float64(U * t_1))); end return tmp end
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(t + N[(N[(l / Om), $MachinePrecision] * N[(l * -2.0 + N[(N[(n * N[(l / Om), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[n, -1.45e-117], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[n, -1.5e-230], N[Sqrt[N[(N[(n * 2.0), $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[n, -1e-309], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t + N[(l / N[(Om / N[(N[(l * -2.0), $MachinePrecision] - N[(N[(U * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(n * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(U * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{\ell}{Om} \cdot \mathsf{fma}\left(\ell, -2, \left(n \cdot \frac{\ell}{Om}\right) \cdot \left(U* - U\right)\right)\\
\mathbf{if}\;n \leq -1.45 \cdot 10^{-117}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot t_1\right)}\\
\mathbf{elif}\;n \leq -1.5 \cdot 10^{-230}:\\
\;\;\;\;\sqrt{\left(n \cdot 2\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}\;n \leq -1 \cdot 10^{-309}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(t + \frac{\ell}{\frac{Om}{\ell \cdot -2 - \frac{U \cdot \left(n \cdot \ell\right)}{Om}}}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{n \cdot 2} \cdot \sqrt{U \cdot t_1}\\
\end{array}
\end{array}
if n < -1.45e-117Initial program 55.2%
associate-*l*53.6%
sub-neg53.6%
associate--l+53.6%
*-commutative53.6%
distribute-rgt-neg-in53.6%
associate-*l/53.7%
associate-*l*53.7%
*-commutative53.7%
*-commutative53.7%
associate-*l*47.6%
unpow247.6%
associate-*l*47.9%
Simplified51.5%
*-un-lft-identity51.5%
associate-*l*51.5%
Applied egg-rr51.5%
*-lft-identity51.5%
associate-*r*55.9%
*-commutative55.9%
associate-*r*59.8%
Simplified59.8%
if -1.45e-117 < n < -1.5e-230Initial program 39.0%
associate-*l*60.9%
sub-neg60.9%
associate--l+60.9%
*-commutative60.9%
distribute-rgt-neg-in60.9%
associate-*l/69.8%
associate-*l*69.8%
*-commutative69.8%
*-commutative69.8%
associate-*l*69.7%
unpow269.7%
associate-*l*69.7%
Simplified69.7%
if -1.5e-230 < n < -1.000000000000002e-309Initial program 27.4%
associate-*l*21.7%
sub-neg21.7%
associate--l+21.7%
*-commutative21.7%
distribute-rgt-neg-in21.7%
associate-*l/40.1%
associate-*l*40.1%
*-commutative40.1%
*-commutative40.1%
associate-*l*40.1%
unpow240.1%
associate-*l*40.2%
Simplified40.2%
Taylor expanded in U* around 0 21.2%
associate-*r*27.3%
+-commutative27.3%
Simplified64.4%
if -1.000000000000002e-309 < n Initial program 55.4%
associate-*l*53.0%
sub-neg53.0%
associate--l+53.0%
*-commutative53.0%
distribute-rgt-neg-in53.0%
associate-*l/56.1%
associate-*l*56.1%
*-commutative56.1%
*-commutative56.1%
associate-*l*52.1%
unpow252.1%
associate-*l*54.5%
Simplified58.5%
sqrt-prod66.9%
*-commutative66.9%
Applied egg-rr66.9%
*-commutative66.9%
*-commutative66.9%
associate-*r*72.3%
Simplified72.3%
Final simplification67.2%
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(*
(* U (* n 2.0))
(+
(- t (* 2.0 (/ (* l l) Om)))
(* (- U* U) (* n (pow (/ l Om) 2.0))))))))
(if (<= t_1 0.0)
(*
(sqrt (* n 2.0))
(sqrt (+ (* U t) (* (* l (* U l)) (/ (- (/ (* n U*) Om) 2.0) Om)))))
(if (<= t_1 INFINITY)
(sqrt
(*
2.0
(*
(* n U)
(+ t (* (/ l Om) (fma l -2.0 (* (* n (/ l Om)) (- U* U))))))))
(sqrt
(*
2.0
(+
(/ (+ (* l -2.0) (/ (* (- U* U) (* n l)) Om)) (/ Om (* n (* U l))))
(* n (* U t)))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((U * (n * 2.0)) * ((t - (2.0 * ((l * l) / Om))) + ((U_42_ - U) * (n * pow((l / Om), 2.0))))));
double tmp;
if (t_1 <= 0.0) {
tmp = sqrt((n * 2.0)) * sqrt(((U * t) + ((l * (U * l)) * ((((n * U_42_) / Om) - 2.0) / Om))));
} else if (t_1 <= ((double) INFINITY)) {
tmp = sqrt((2.0 * ((n * U) * (t + ((l / Om) * fma(l, -2.0, ((n * (l / Om)) * (U_42_ - U))))))));
} else {
tmp = sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t)))));
}
return tmp;
}
function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(U * Float64(n * 2.0)) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) + Float64(Float64(U_42_ - U) * Float64(n * (Float64(l / Om) ^ 2.0)))))) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(sqrt(Float64(n * 2.0)) * sqrt(Float64(Float64(U * t) + Float64(Float64(l * Float64(U * l)) * Float64(Float64(Float64(Float64(n * U_42_) / Om) - 2.0) / Om))))); elseif (t_1 <= Inf) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(Float64(l / Om) * fma(l, -2.0, Float64(Float64(n * Float64(l / Om)) * Float64(U_42_ - U)))))))); else tmp = sqrt(Float64(2.0 * Float64(Float64(Float64(Float64(l * -2.0) + Float64(Float64(Float64(U_42_ - U) * Float64(n * l)) / Om)) / Float64(Om / Float64(n * Float64(U * l)))) + Float64(n * Float64(U * t))))); end return tmp end
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(U * N[(n * 2.0), $MachinePrecision]), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(U$42$ - U), $MachinePrecision] * N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[(N[Sqrt[N[(n * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(N[(U * t), $MachinePrecision] + N[(N[(l * N[(U * l), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(N[(l / Om), $MachinePrecision] * N[(l * -2.0 + N[(N[(n * N[(l / Om), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(N[(N[(N[(l * -2.0), $MachinePrecision] + N[(N[(N[(U$42$ - U), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(n * N[(U * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{\left(U \cdot \left(n \cdot 2\right)\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) + \left(U* - U\right) \cdot \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right)\right)}\\
\mathbf{if}\;t_1 \leq 0:\\
\;\;\;\;\sqrt{n \cdot 2} \cdot \sqrt{U \cdot t + \left(\ell \cdot \left(U \cdot \ell\right)\right) \cdot \frac{\frac{n \cdot U*}{Om} - 2}{Om}}\\
\mathbf{elif}\;t_1 \leq \infty:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + \frac{\ell}{Om} \cdot \mathsf{fma}\left(\ell, -2, \left(n \cdot \frac{\ell}{Om}\right) \cdot \left(U* - U\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(\frac{\ell \cdot -2 + \frac{\left(U* - U\right) \cdot \left(n \cdot \ell\right)}{Om}}{\frac{Om}{n \cdot \left(U \cdot \ell\right)}} + n \cdot \left(U \cdot t\right)\right)}\\
\end{array}
\end{array}
if (sqrt.f64 (*.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*))))) < 0.0Initial program 8.9%
associate-*l*28.0%
sub-neg28.0%
associate--l+28.0%
*-commutative28.0%
distribute-rgt-neg-in28.0%
associate-*l/28.0%
associate-*l*28.0%
*-commutative28.0%
*-commutative28.0%
associate-*l*27.9%
unpow227.9%
associate-*l*27.9%
Simplified27.9%
Taylor expanded in l around -inf 24.8%
mul-1-neg24.8%
unsub-neg24.8%
*-commutative24.8%
associate-/l*24.8%
mul-1-neg24.8%
unsub-neg24.8%
associate-/l*24.6%
*-commutative24.6%
unpow224.6%
Simplified24.6%
sqrt-prod33.5%
associate-/r/33.6%
associate-/r/33.6%
associate-*r*33.6%
Applied egg-rr33.6%
Taylor expanded in U* around inf 33.6%
if 0.0 < (sqrt.f64 (*.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*))))) < +inf.0Initial program 68.2%
associate-*l*64.7%
sub-neg64.7%
associate--l+64.7%
*-commutative64.7%
distribute-rgt-neg-in64.7%
associate-*l/67.2%
associate-*l*67.2%
*-commutative67.2%
*-commutative67.2%
associate-*l*61.8%
unpow261.8%
associate-*l*61.9%
Simplified61.9%
*-un-lft-identity61.9%
associate-*l*61.9%
Applied egg-rr61.9%
*-lft-identity61.9%
associate-*r*68.2%
*-commutative68.2%
associate-*r*72.2%
Simplified72.2%
if +inf.0 < (sqrt.f64 (*.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 0.0%
associate-*l*1.1%
sub-neg1.1%
associate--l+1.1%
*-commutative1.1%
distribute-rgt-neg-in1.1%
associate-*l/12.9%
associate-*l*12.9%
*-commutative12.9%
*-commutative12.9%
associate-*l*12.9%
unpow212.9%
associate-*l*22.0%
Simplified46.7%
*-un-lft-identity46.7%
associate-*l*46.7%
Applied egg-rr46.7%
*-lft-identity46.7%
associate-*r*32.3%
*-commutative32.3%
associate-*r*34.7%
Simplified34.7%
Taylor expanded in t around 0 48.8%
associate-/l*48.9%
+-commutative48.9%
*-commutative48.9%
associate-*r*54.4%
*-commutative54.4%
Simplified54.4%
Final simplification65.3%
(FPCore (n U t l Om U*)
:precision binary64
(if (or (<= U -3.3e-141) (not (<= U 1.05e-150)))
(sqrt
(*
2.0
(* (* n U) (+ t (* (/ l Om) (fma l -2.0 (* (* n (/ l Om)) (- U* U))))))))
(sqrt
(-
(* 2.0 (* n (* U t)))
(*
2.0
(/ (* (* n (* U l)) (- (/ (* n (* l (- U U*))) Om) (* l -2.0))) Om))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((U <= -3.3e-141) || !(U <= 1.05e-150)) {
tmp = sqrt((2.0 * ((n * U) * (t + ((l / Om) * fma(l, -2.0, ((n * (l / Om)) * (U_42_ - U))))))));
} else {
tmp = sqrt(((2.0 * (n * (U * t))) - (2.0 * (((n * (U * l)) * (((n * (l * (U - U_42_))) / Om) - (l * -2.0))) / Om))));
}
return tmp;
}
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((U <= -3.3e-141) || !(U <= 1.05e-150)) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(Float64(l / Om) * fma(l, -2.0, Float64(Float64(n * Float64(l / Om)) * Float64(U_42_ - U)))))))); else tmp = sqrt(Float64(Float64(2.0 * Float64(n * Float64(U * t))) - Float64(2.0 * Float64(Float64(Float64(n * Float64(U * l)) * Float64(Float64(Float64(n * Float64(l * Float64(U - U_42_))) / Om) - Float64(l * -2.0))) / Om)))); end return tmp end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[U, -3.3e-141], N[Not[LessEqual[U, 1.05e-150]], $MachinePrecision]], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(N[(l / Om), $MachinePrecision] * N[(l * -2.0 + N[(N[(n * N[(l / Om), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(2.0 * N[(N[(N[(n * N[(U * l), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(n * N[(l * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - N[(l * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;U \leq -3.3 \cdot 10^{-141} \lor \neg \left(U \leq 1.05 \cdot 10^{-150}\right):\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + \frac{\ell}{Om} \cdot \mathsf{fma}\left(\ell, -2, \left(n \cdot \frac{\ell}{Om}\right) \cdot \left(U* - U\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot t\right)\right) - 2 \cdot \frac{\left(n \cdot \left(U \cdot \ell\right)\right) \cdot \left(\frac{n \cdot \left(\ell \cdot \left(U - U*\right)\right)}{Om} - \ell \cdot -2\right)}{Om}}\\
\end{array}
\end{array}
if U < -3.29999999999999999e-141 or 1.0500000000000001e-150 < U Initial program 60.1%
associate-*l*57.9%
sub-neg57.9%
associate--l+57.9%
*-commutative57.9%
distribute-rgt-neg-in57.9%
associate-*l/62.5%
associate-*l*62.5%
*-commutative62.5%
*-commutative62.5%
associate-*l*58.7%
unpow258.7%
associate-*l*58.9%
Simplified61.4%
*-un-lft-identity61.4%
associate-*l*61.4%
Applied egg-rr61.4%
*-lft-identity61.4%
associate-*r*66.4%
*-commutative66.4%
associate-*r*69.1%
Simplified69.1%
if -3.29999999999999999e-141 < U < 1.0500000000000001e-150Initial program 36.2%
associate-*l*39.9%
sub-neg39.9%
associate--l+39.9%
*-commutative39.9%
distribute-rgt-neg-in39.9%
associate-*l/41.1%
associate-*l*41.1%
*-commutative41.1%
*-commutative41.1%
associate-*l*36.4%
unpow236.4%
associate-*l*40.1%
Simplified44.9%
Taylor expanded in t around inf 55.7%
Final simplification64.6%
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l -1e+106)
(sqrt
(*
2.0
(+
(/ (+ (* l -2.0) (/ (* (- U* U) (* n l)) Om)) (/ Om (* n (* U l))))
(* n (* U t)))))
(if (<= l 1.1e+72)
(sqrt
(*
(* n 2.0)
(* U (+ t (/ (* l (+ (* l -2.0) (/ (* n (* l U*)) Om))) Om)))))
(*
(* l (sqrt 2.0))
(sqrt (/ n (/ Om (* U (- -2.0 (* (- U U*) (/ n Om)))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= -1e+106) {
tmp = sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t)))));
} else if (l <= 1.1e+72) {
tmp = sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om)))));
} else {
tmp = (l * sqrt(2.0)) * sqrt((n / (Om / (U * (-2.0 - ((U - U_42_) * (n / Om)))))));
}
return tmp;
}
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 <= (-1d+106)) then
tmp = sqrt((2.0d0 * ((((l * (-2.0d0)) + (((u_42 - u) * (n * l)) / om)) / (om / (n * (u * l)))) + (n * (u * t)))))
else if (l <= 1.1d+72) then
tmp = sqrt(((n * 2.0d0) * (u * (t + ((l * ((l * (-2.0d0)) + ((n * (l * u_42)) / om))) / om)))))
else
tmp = (l * sqrt(2.0d0)) * sqrt((n / (om / (u * ((-2.0d0) - ((u - u_42) * (n / om)))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= -1e+106) {
tmp = Math.sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t)))));
} else if (l <= 1.1e+72) {
tmp = Math.sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om)))));
} else {
tmp = (l * Math.sqrt(2.0)) * Math.sqrt((n / (Om / (U * (-2.0 - ((U - U_42_) * (n / Om)))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= -1e+106: tmp = math.sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t))))) elif l <= 1.1e+72: tmp = math.sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om))))) else: tmp = (l * math.sqrt(2.0)) * math.sqrt((n / (Om / (U * (-2.0 - ((U - U_42_) * (n / Om))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= -1e+106) tmp = sqrt(Float64(2.0 * Float64(Float64(Float64(Float64(l * -2.0) + Float64(Float64(Float64(U_42_ - U) * Float64(n * l)) / Om)) / Float64(Om / Float64(n * Float64(U * l)))) + Float64(n * Float64(U * t))))); elseif (l <= 1.1e+72) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(U * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + Float64(Float64(n * Float64(l * U_42_)) / Om))) / Om))))); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(n / Float64(Om / Float64(U * Float64(-2.0 - Float64(Float64(U - U_42_) * Float64(n / Om)))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= -1e+106) tmp = sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t))))); elseif (l <= 1.1e+72) tmp = sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om))))); else tmp = (l * sqrt(2.0)) * sqrt((n / (Om / (U * (-2.0 - ((U - U_42_) * (n / Om))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, -1e+106], N[Sqrt[N[(2.0 * N[(N[(N[(N[(l * -2.0), $MachinePrecision] + N[(N[(N[(U$42$ - U), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(n * N[(U * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 1.1e+72], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(U * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + N[(N[(n * N[(l * U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(n / N[(Om / N[(U * N[(-2.0 - N[(N[(U - U$42$), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -1 \cdot 10^{+106}:\\
\;\;\;\;\sqrt{2 \cdot \left(\frac{\ell \cdot -2 + \frac{\left(U* - U\right) \cdot \left(n \cdot \ell\right)}{Om}}{\frac{Om}{n \cdot \left(U \cdot \ell\right)}} + n \cdot \left(U \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 1.1 \cdot 10^{+72}:\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + \frac{n \cdot \left(\ell \cdot U*\right)}{Om}\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{\frac{n}{\frac{Om}{U \cdot \left(-2 - \left(U - U*\right) \cdot \frac{n}{Om}\right)}}}\\
\end{array}
\end{array}
if l < -1.00000000000000009e106Initial program 30.0%
associate-*l*27.4%
sub-neg27.4%
associate--l+27.4%
*-commutative27.4%
distribute-rgt-neg-in27.4%
associate-*l/47.2%
associate-*l*47.2%
*-commutative47.2%
*-commutative47.2%
associate-*l*50.0%
unpow250.0%
associate-*l*50.1%
Simplified58.8%
*-un-lft-identity58.8%
associate-*l*58.8%
Applied egg-rr58.8%
*-lft-identity58.8%
associate-*r*59.6%
*-commutative59.6%
associate-*r*56.7%
Simplified56.7%
Taylor expanded in t around 0 50.1%
associate-/l*53.0%
+-commutative53.0%
*-commutative53.0%
associate-*r*61.6%
*-commutative61.6%
Simplified61.6%
if -1.00000000000000009e106 < l < 1.1e72Initial program 62.0%
associate-*l*62.7%
sub-neg62.7%
associate--l+62.7%
*-commutative62.7%
distribute-rgt-neg-in62.7%
associate-*l/62.7%
associate-*l*62.7%
*-commutative62.7%
*-commutative62.7%
associate-*l*56.9%
unpow256.9%
associate-*l*58.7%
Simplified59.2%
Taylor expanded in U around 0 64.6%
if 1.1e72 < l Initial program 31.0%
associate-*l*29.1%
sub-neg29.1%
associate--l+29.1%
*-commutative29.1%
distribute-rgt-neg-in29.1%
associate-*l/33.4%
associate-*l*33.4%
*-commutative33.4%
*-commutative33.4%
associate-*l*30.6%
unpow230.6%
associate-*l*30.9%
Simplified40.6%
*-un-lft-identity40.6%
associate-*l*40.6%
Applied egg-rr40.6%
*-lft-identity40.6%
associate-*r*46.5%
*-commutative46.5%
associate-*r*46.7%
Simplified46.7%
Taylor expanded in t around 0 35.3%
associate-/l*35.2%
+-commutative35.2%
*-commutative35.2%
associate-*r*37.7%
*-commutative37.7%
Simplified37.7%
Taylor expanded in l around inf 52.4%
associate-/l*54.8%
*-commutative54.8%
sub-neg54.8%
*-commutative54.8%
associate-*r/54.9%
metadata-eval54.9%
Simplified54.9%
Final simplification62.5%
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l -5.1e+104)
(sqrt
(*
2.0
(+
(/ (+ (* l -2.0) (/ (* (- U* U) (* n l)) Om)) (/ Om (* n (* U l))))
(* n (* U t)))))
(if (<= l 1.5e+73)
(sqrt
(*
(* n 2.0)
(* U (+ t (/ (* l (+ (* l -2.0) (/ (* n (* l U*)) Om))) Om)))))
(* (* l (sqrt 2.0)) (sqrt (/ n (/ Om (* U (+ -2.0 (/ n (/ Om U*)))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= -5.1e+104) {
tmp = sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t)))));
} else if (l <= 1.5e+73) {
tmp = sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om)))));
} else {
tmp = (l * sqrt(2.0)) * sqrt((n / (Om / (U * (-2.0 + (n / (Om / U_42_)))))));
}
return tmp;
}
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.1d+104)) then
tmp = sqrt((2.0d0 * ((((l * (-2.0d0)) + (((u_42 - u) * (n * l)) / om)) / (om / (n * (u * l)))) + (n * (u * t)))))
else if (l <= 1.5d+73) then
tmp = sqrt(((n * 2.0d0) * (u * (t + ((l * ((l * (-2.0d0)) + ((n * (l * u_42)) / om))) / om)))))
else
tmp = (l * sqrt(2.0d0)) * sqrt((n / (om / (u * ((-2.0d0) + (n / (om / u_42)))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= -5.1e+104) {
tmp = Math.sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t)))));
} else if (l <= 1.5e+73) {
tmp = Math.sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om)))));
} else {
tmp = (l * Math.sqrt(2.0)) * Math.sqrt((n / (Om / (U * (-2.0 + (n / (Om / U_42_)))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= -5.1e+104: tmp = math.sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t))))) elif l <= 1.5e+73: tmp = math.sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om))))) else: tmp = (l * math.sqrt(2.0)) * math.sqrt((n / (Om / (U * (-2.0 + (n / (Om / U_42_))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= -5.1e+104) tmp = sqrt(Float64(2.0 * Float64(Float64(Float64(Float64(l * -2.0) + Float64(Float64(Float64(U_42_ - U) * Float64(n * l)) / Om)) / Float64(Om / Float64(n * Float64(U * l)))) + Float64(n * Float64(U * t))))); elseif (l <= 1.5e+73) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(U * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + Float64(Float64(n * Float64(l * U_42_)) / Om))) / Om))))); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(n / Float64(Om / Float64(U * Float64(-2.0 + Float64(n / Float64(Om / U_42_)))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= -5.1e+104) tmp = sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t))))); elseif (l <= 1.5e+73) tmp = sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om))))); else tmp = (l * sqrt(2.0)) * sqrt((n / (Om / (U * (-2.0 + (n / (Om / U_42_))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, -5.1e+104], N[Sqrt[N[(2.0 * N[(N[(N[(N[(l * -2.0), $MachinePrecision] + N[(N[(N[(U$42$ - U), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(n * N[(U * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 1.5e+73], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(U * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + N[(N[(n * N[(l * U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(n / N[(Om / N[(U * N[(-2.0 + N[(n / N[(Om / U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -5.1 \cdot 10^{+104}:\\
\;\;\;\;\sqrt{2 \cdot \left(\frac{\ell \cdot -2 + \frac{\left(U* - U\right) \cdot \left(n \cdot \ell\right)}{Om}}{\frac{Om}{n \cdot \left(U \cdot \ell\right)}} + n \cdot \left(U \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 1.5 \cdot 10^{+73}:\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + \frac{n \cdot \left(\ell \cdot U*\right)}{Om}\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{\frac{n}{\frac{Om}{U \cdot \left(-2 + \frac{n}{\frac{Om}{U*}}\right)}}}\\
\end{array}
\end{array}
if l < -5.1000000000000002e104Initial program 30.0%
associate-*l*27.4%
sub-neg27.4%
associate--l+27.4%
*-commutative27.4%
distribute-rgt-neg-in27.4%
associate-*l/47.2%
associate-*l*47.2%
*-commutative47.2%
*-commutative47.2%
associate-*l*50.0%
unpow250.0%
associate-*l*50.1%
Simplified58.8%
*-un-lft-identity58.8%
associate-*l*58.8%
Applied egg-rr58.8%
*-lft-identity58.8%
associate-*r*59.6%
*-commutative59.6%
associate-*r*56.7%
Simplified56.7%
Taylor expanded in t around 0 50.1%
associate-/l*53.0%
+-commutative53.0%
*-commutative53.0%
associate-*r*61.6%
*-commutative61.6%
Simplified61.6%
if -5.1000000000000002e104 < l < 1.50000000000000005e73Initial program 62.0%
associate-*l*62.7%
sub-neg62.7%
associate--l+62.7%
*-commutative62.7%
distribute-rgt-neg-in62.7%
associate-*l/62.7%
associate-*l*62.7%
*-commutative62.7%
*-commutative62.7%
associate-*l*56.9%
unpow256.9%
associate-*l*58.7%
Simplified59.2%
Taylor expanded in U around 0 64.6%
if 1.50000000000000005e73 < l Initial program 31.0%
associate-*l*29.1%
sub-neg29.1%
associate--l+29.1%
*-commutative29.1%
distribute-rgt-neg-in29.1%
associate-*l/33.4%
associate-*l*33.4%
*-commutative33.4%
*-commutative33.4%
associate-*l*30.6%
unpow230.6%
associate-*l*30.9%
Simplified40.6%
*-un-lft-identity40.6%
associate-*l*40.6%
Applied egg-rr40.6%
*-lft-identity40.6%
associate-*r*46.5%
*-commutative46.5%
associate-*r*46.7%
Simplified46.7%
Taylor expanded in t around 0 35.3%
associate-/l*35.2%
+-commutative35.2%
*-commutative35.2%
associate-*r*37.7%
*-commutative37.7%
Simplified37.7%
Taylor expanded in U* around inf 36.3%
Taylor expanded in l around inf 51.7%
*-commutative51.7%
*-commutative51.7%
associate-/l*54.0%
*-commutative54.0%
sub-neg54.0%
associate-/l*54.0%
metadata-eval54.0%
*-commutative54.0%
Simplified54.0%
Final simplification62.3%
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(*
(* n 2.0)
(/ (* U (* l l)) (/ Om (- -2.0 (* (- U U*) (/ n Om))))))))
(t_2 (sqrt (* (* n 2.0) (- (* U t) (* 2.0 (/ (* l l) (/ Om U))))))))
(if (<= l -2.7e-17)
t_1
(if (<= l -2.1e-88)
t_2
(if (<= l -1.1e-106)
(sqrt (* n (/ (* 2.0 (* n (* (* l l) (* U U*)))) (* Om Om))))
(if (<= l 2.05e-135)
(pow (* 2.0 (* n (* U t))) 0.5)
(if (<= l 4.2e-40)
(sqrt (* 2.0 (* (* n U) (+ t (* -2.0 (/ (* l l) Om))))))
(if (<= l 1.7e+45) t_2 t_1))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((n * 2.0) * ((U * (l * l)) / (Om / (-2.0 - ((U - U_42_) * (n / Om)))))));
double t_2 = sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U))))));
double tmp;
if (l <= -2.7e-17) {
tmp = t_1;
} else if (l <= -2.1e-88) {
tmp = t_2;
} else if (l <= -1.1e-106) {
tmp = sqrt((n * ((2.0 * (n * ((l * l) * (U * U_42_)))) / (Om * Om))));
} else if (l <= 2.05e-135) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else if (l <= 4.2e-40) {
tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else if (l <= 1.7e+45) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
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 = sqrt(((n * 2.0d0) * ((u * (l * l)) / (om / ((-2.0d0) - ((u - u_42) * (n / om)))))))
t_2 = sqrt(((n * 2.0d0) * ((u * t) - (2.0d0 * ((l * l) / (om / u))))))
if (l <= (-2.7d-17)) then
tmp = t_1
else if (l <= (-2.1d-88)) then
tmp = t_2
else if (l <= (-1.1d-106)) then
tmp = sqrt((n * ((2.0d0 * (n * ((l * l) * (u * u_42)))) / (om * om))))
else if (l <= 2.05d-135) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else if (l <= 4.2d-40) then
tmp = sqrt((2.0d0 * ((n * u) * (t + ((-2.0d0) * ((l * l) / om))))))
else if (l <= 1.7d+45) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((n * 2.0) * ((U * (l * l)) / (Om / (-2.0 - ((U - U_42_) * (n / Om)))))));
double t_2 = Math.sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U))))));
double tmp;
if (l <= -2.7e-17) {
tmp = t_1;
} else if (l <= -2.1e-88) {
tmp = t_2;
} else if (l <= -1.1e-106) {
tmp = Math.sqrt((n * ((2.0 * (n * ((l * l) * (U * U_42_)))) / (Om * Om))));
} else if (l <= 2.05e-135) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else if (l <= 4.2e-40) {
tmp = Math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else if (l <= 1.7e+45) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((n * 2.0) * ((U * (l * l)) / (Om / (-2.0 - ((U - U_42_) * (n / Om))))))) t_2 = math.sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U)))))) tmp = 0 if l <= -2.7e-17: tmp = t_1 elif l <= -2.1e-88: tmp = t_2 elif l <= -1.1e-106: tmp = math.sqrt((n * ((2.0 * (n * ((l * l) * (U * U_42_)))) / (Om * Om)))) elif l <= 2.05e-135: tmp = math.pow((2.0 * (n * (U * t))), 0.5) elif l <= 4.2e-40: tmp = math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))) elif l <= 1.7e+45: tmp = t_2 else: tmp = t_1 return tmp
function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(U * Float64(l * l)) / Float64(Om / Float64(-2.0 - Float64(Float64(U - U_42_) * Float64(n / Om))))))) t_2 = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(U * t) - Float64(2.0 * Float64(Float64(l * l) / Float64(Om / U)))))) tmp = 0.0 if (l <= -2.7e-17) tmp = t_1; elseif (l <= -2.1e-88) tmp = t_2; elseif (l <= -1.1e-106) tmp = sqrt(Float64(n * Float64(Float64(2.0 * Float64(n * Float64(Float64(l * l) * Float64(U * U_42_)))) / Float64(Om * Om)))); elseif (l <= 2.05e-135) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; elseif (l <= 4.2e-40) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(-2.0 * Float64(Float64(l * l) / Om)))))); elseif (l <= 1.7e+45) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((n * 2.0) * ((U * (l * l)) / (Om / (-2.0 - ((U - U_42_) * (n / Om))))))); t_2 = sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U)))))); tmp = 0.0; if (l <= -2.7e-17) tmp = t_1; elseif (l <= -2.1e-88) tmp = t_2; elseif (l <= -1.1e-106) tmp = sqrt((n * ((2.0 * (n * ((l * l) * (U * U_42_)))) / (Om * Om)))); elseif (l <= 2.05e-135) tmp = (2.0 * (n * (U * t))) ^ 0.5; elseif (l <= 4.2e-40) tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))); elseif (l <= 1.7e+45) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(U * N[(l * l), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(-2.0 - N[(N[(U - U$42$), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(U * t), $MachinePrecision] - N[(2.0 * N[(N[(l * l), $MachinePrecision] / N[(Om / U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, -2.7e-17], t$95$1, If[LessEqual[l, -2.1e-88], t$95$2, If[LessEqual[l, -1.1e-106], N[Sqrt[N[(n * N[(N[(2.0 * N[(n * N[(N[(l * l), $MachinePrecision] * N[(U * U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 2.05e-135], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], If[LessEqual[l, 4.2e-40], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 1.7e+45], t$95$2, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{\left(n \cdot 2\right) \cdot \frac{U \cdot \left(\ell \cdot \ell\right)}{\frac{Om}{-2 - \left(U - U*\right) \cdot \frac{n}{Om}}}}\\
t_2 := \sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot t - 2 \cdot \frac{\ell \cdot \ell}{\frac{Om}{U}}\right)}\\
\mathbf{if}\;\ell \leq -2.7 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq -2.1 \cdot 10^{-88}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;\ell \leq -1.1 \cdot 10^{-106}:\\
\;\;\;\;\sqrt{n \cdot \frac{2 \cdot \left(n \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(U \cdot U*\right)\right)\right)}{Om \cdot Om}}\\
\mathbf{elif}\;\ell \leq 2.05 \cdot 10^{-135}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{elif}\;\ell \leq 4.2 \cdot 10^{-40}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + -2 \cdot \frac{\ell \cdot \ell}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 1.7 \cdot 10^{+45}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if l < -2.7000000000000001e-17 or 1.7e45 < l Initial program 36.6%
associate-*l*34.9%
sub-neg34.9%
associate--l+34.9%
*-commutative34.9%
distribute-rgt-neg-in34.9%
associate-*l/43.2%
associate-*l*43.2%
*-commutative43.2%
*-commutative43.2%
associate-*l*42.8%
unpow242.8%
associate-*l*43.9%
Simplified51.7%
Taylor expanded in l around -inf 41.7%
associate-*r/41.7%
mul-1-neg41.7%
*-commutative41.7%
*-commutative41.7%
unpow241.7%
mul-1-neg41.7%
unsub-neg41.7%
associate-/l*41.7%
Simplified41.7%
Taylor expanded in l around 0 41.7%
mul-1-neg41.7%
associate-*l/41.7%
*-commutative41.7%
unpow241.7%
*-commutative41.7%
distribute-neg-frac41.7%
distribute-rgt-neg-out41.7%
associate-/l*42.6%
neg-sub042.6%
associate--r-42.6%
metadata-eval42.6%
*-commutative42.6%
Simplified42.6%
if -2.7000000000000001e-17 < l < -2.1e-88 or 4.20000000000000036e-40 < l < 1.7e45Initial program 55.3%
associate-*l*58.8%
sub-neg58.8%
associate--l+58.8%
*-commutative58.8%
distribute-rgt-neg-in58.8%
associate-*l/58.8%
associate-*l*58.8%
*-commutative58.8%
*-commutative58.8%
associate-*l*53.6%
unpow253.6%
associate-*l*59.7%
Simplified59.7%
Taylor expanded in l around -inf 59.4%
mul-1-neg59.4%
unsub-neg59.4%
*-commutative59.4%
associate-/l*59.4%
mul-1-neg59.4%
unsub-neg59.4%
associate-/l*62.4%
*-commutative62.4%
unpow262.4%
Simplified62.4%
Taylor expanded in n around 0 58.0%
associate-/l*58.1%
unpow258.1%
Simplified58.1%
if -2.1e-88 < l < -1.09999999999999997e-106Initial program 68.4%
*-commutative68.4%
associate-*l*68.4%
associate-*l*68.4%
associate-*l*68.4%
sub-neg68.4%
+-commutative68.4%
*-commutative68.4%
distribute-rgt-neg-in68.4%
fma-def68.4%
associate-*r/68.4%
metadata-eval68.4%
Simplified68.4%
Taylor expanded in U* around inf 76.8%
associate-*r/76.8%
*-commutative76.8%
unpow276.8%
*-commutative76.8%
unpow276.8%
Simplified76.8%
if -1.09999999999999997e-106 < l < 2.05000000000000005e-135Initial program 68.4%
associate-*l*71.8%
sub-neg71.8%
associate--l+71.8%
*-commutative71.8%
distribute-rgt-neg-in71.8%
associate-*l/71.8%
associate-*l*71.8%
*-commutative71.8%
*-commutative71.8%
associate-*l*63.2%
unpow263.2%
associate-*l*63.4%
Simplified63.4%
Taylor expanded in t around inf 65.6%
pow1/266.9%
associate-*l*66.9%
*-commutative66.9%
Applied egg-rr66.9%
if 2.05000000000000005e-135 < l < 4.20000000000000036e-40Initial program 56.5%
associate-*l*45.3%
sub-neg45.3%
associate--l+45.3%
*-commutative45.3%
distribute-rgt-neg-in45.3%
associate-*l/45.3%
associate-*l*45.3%
*-commutative45.3%
*-commutative45.3%
associate-*l*40.9%
unpow240.9%
associate-*l*41.3%
Simplified41.3%
*-un-lft-identity41.3%
associate-*l*41.3%
Applied egg-rr41.3%
*-lft-identity41.3%
associate-*r*52.6%
*-commutative52.6%
associate-*r*56.6%
Simplified56.6%
Taylor expanded in n around 0 48.6%
unpow248.6%
Simplified48.6%
Final simplification54.0%
(FPCore (n U t l Om U*)
:precision binary64
(if (or (<= n -1.15e-204) (not (<= n 5.8e-195)))
(sqrt
(*
2.0
(+
(* n (* U t))
(/ (+ (* l -2.0) (/ (* n (* l U*)) Om)) (/ Om (* n (* U l)))))))
(sqrt
(*
2.0
(* U (* n (+ t (/ l (/ Om (- (* l -2.0) (/ (* U (* n l)) Om)))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.15e-204) || !(n <= 5.8e-195)) {
tmp = sqrt((2.0 * ((n * (U * t)) + (((l * -2.0) + ((n * (l * U_42_)) / Om)) / (Om / (n * (U * l)))))));
} else {
tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
}
return tmp;
}
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 ((n <= (-1.15d-204)) .or. (.not. (n <= 5.8d-195))) then
tmp = sqrt((2.0d0 * ((n * (u * t)) + (((l * (-2.0d0)) + ((n * (l * u_42)) / om)) / (om / (n * (u * l)))))))
else
tmp = sqrt((2.0d0 * (u * (n * (t + (l / (om / ((l * (-2.0d0)) - ((u * (n * l)) / om)))))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.15e-204) || !(n <= 5.8e-195)) {
tmp = Math.sqrt((2.0 * ((n * (U * t)) + (((l * -2.0) + ((n * (l * U_42_)) / Om)) / (Om / (n * (U * l)))))));
} else {
tmp = Math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if (n <= -1.15e-204) or not (n <= 5.8e-195): tmp = math.sqrt((2.0 * ((n * (U * t)) + (((l * -2.0) + ((n * (l * U_42_)) / Om)) / (Om / (n * (U * l))))))) else: tmp = math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((n <= -1.15e-204) || !(n <= 5.8e-195)) tmp = sqrt(Float64(2.0 * Float64(Float64(n * Float64(U * t)) + Float64(Float64(Float64(l * -2.0) + Float64(Float64(n * Float64(l * U_42_)) / Om)) / Float64(Om / Float64(n * Float64(U * l))))))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(t + Float64(l / Float64(Om / Float64(Float64(l * -2.0) - Float64(Float64(U * Float64(n * l)) / Om))))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if ((n <= -1.15e-204) || ~((n <= 5.8e-195))) tmp = sqrt((2.0 * ((n * (U * t)) + (((l * -2.0) + ((n * (l * U_42_)) / Om)) / (Om / (n * (U * l))))))); else tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[n, -1.15e-204], N[Not[LessEqual[n, 5.8e-195]], $MachinePrecision]], N[Sqrt[N[(2.0 * N[(N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(l * -2.0), $MachinePrecision] + N[(N[(n * N[(l * U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(n * N[(U * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t + N[(l / N[(Om / N[(N[(l * -2.0), $MachinePrecision] - N[(N[(U * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.15 \cdot 10^{-204} \lor \neg \left(n \leq 5.8 \cdot 10^{-195}\right):\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot t\right) + \frac{\ell \cdot -2 + \frac{n \cdot \left(\ell \cdot U*\right)}{Om}}{\frac{Om}{n \cdot \left(U \cdot \ell\right)}}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(t + \frac{\ell}{\frac{Om}{\ell \cdot -2 - \frac{U \cdot \left(n \cdot \ell\right)}{Om}}}\right)\right)\right)}\\
\end{array}
\end{array}
if n < -1.15e-204 or 5.8000000000000003e-195 < n Initial program 55.5%
associate-*l*56.8%
sub-neg56.8%
associate--l+56.8%
*-commutative56.8%
distribute-rgt-neg-in56.8%
associate-*l/58.8%
associate-*l*58.8%
*-commutative58.8%
*-commutative58.8%
associate-*l*53.7%
unpow253.7%
associate-*l*54.3%
Simplified58.4%
*-un-lft-identity58.4%
associate-*l*58.4%
Applied egg-rr58.4%
*-lft-identity58.4%
associate-*r*58.3%
*-commutative58.3%
associate-*r*62.4%
Simplified62.4%
Taylor expanded in t around 0 59.9%
associate-/l*61.9%
+-commutative61.9%
*-commutative61.9%
associate-*r*60.8%
*-commutative60.8%
Simplified60.8%
Taylor expanded in U* around inf 62.4%
if -1.15e-204 < n < 5.8000000000000003e-195Initial program 38.8%
associate-*l*32.3%
sub-neg32.3%
associate--l+32.3%
*-commutative32.3%
distribute-rgt-neg-in32.3%
associate-*l/41.9%
associate-*l*41.9%
*-commutative41.9%
*-commutative41.9%
associate-*l*41.8%
unpow241.8%
associate-*l*45.8%
Simplified45.9%
Taylor expanded in U* around 0 34.0%
associate-*r*36.5%
+-commutative36.5%
Simplified56.1%
Final simplification61.2%
(FPCore (n U t l Om U*)
:precision binary64
(if (<= U -4.4e+99)
(sqrt
(* 2.0 (* U (* n (+ t (/ l (/ Om (- (* l -2.0) (/ (* U (* n l)) Om)))))))))
(sqrt
(*
2.0
(+
(/ (+ (* l -2.0) (/ (* (- U* U) (* n l)) Om)) (/ Om (* n (* U l))))
(* n (* U t)))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= -4.4e+99) {
tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
} else {
tmp = sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t)))));
}
return tmp;
}
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.4d+99)) then
tmp = sqrt((2.0d0 * (u * (n * (t + (l / (om / ((l * (-2.0d0)) - ((u * (n * l)) / om)))))))))
else
tmp = sqrt((2.0d0 * ((((l * (-2.0d0)) + (((u_42 - u) * (n * l)) / om)) / (om / (n * (u * l)))) + (n * (u * t)))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U <= -4.4e+99) {
tmp = Math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
} else {
tmp = Math.sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t)))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if U <= -4.4e+99: tmp = math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))) else: tmp = math.sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U <= -4.4e+99) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(t + Float64(l / Float64(Om / Float64(Float64(l * -2.0) - Float64(Float64(U * Float64(n * l)) / Om))))))))); else tmp = sqrt(Float64(2.0 * Float64(Float64(Float64(Float64(l * -2.0) + Float64(Float64(Float64(U_42_ - U) * Float64(n * l)) / Om)) / Float64(Om / Float64(n * Float64(U * l)))) + Float64(n * Float64(U * t))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U <= -4.4e+99) tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))); else tmp = sqrt((2.0 * ((((l * -2.0) + (((U_42_ - U) * (n * l)) / Om)) / (Om / (n * (U * l)))) + (n * (U * t))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U, -4.4e+99], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t + N[(l / N[(Om / N[(N[(l * -2.0), $MachinePrecision] - N[(N[(U * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(N[(N[(N[(l * -2.0), $MachinePrecision] + N[(N[(N[(U$42$ - U), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(n * N[(U * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;U \leq -4.4 \cdot 10^{+99}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(t + \frac{\ell}{\frac{Om}{\ell \cdot -2 - \frac{U \cdot \left(n \cdot \ell\right)}{Om}}}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(\frac{\ell \cdot -2 + \frac{\left(U* - U\right) \cdot \left(n \cdot \ell\right)}{Om}}{\frac{Om}{n \cdot \left(U \cdot \ell\right)}} + n \cdot \left(U \cdot t\right)\right)}\\
\end{array}
\end{array}
if U < -4.39999999999999956e99Initial program 59.0%
associate-*l*37.8%
sub-neg37.8%
associate--l+37.8%
*-commutative37.8%
distribute-rgt-neg-in37.8%
associate-*l/37.8%
associate-*l*37.8%
*-commutative37.8%
*-commutative37.8%
associate-*l*27.1%
unpow227.1%
associate-*l*27.3%
Simplified27.7%
Taylor expanded in U* around 0 26.1%
associate-*r*41.2%
+-commutative41.2%
Simplified53.7%
if -4.39999999999999956e99 < U Initial program 51.2%
associate-*l*54.0%
sub-neg54.0%
associate--l+54.0%
*-commutative54.0%
distribute-rgt-neg-in54.0%
associate-*l/57.9%
associate-*l*57.9%
*-commutative57.9%
*-commutative57.9%
associate-*l*54.8%
unpow254.8%
associate-*l*56.2%
Simplified59.9%
*-un-lft-identity59.9%
associate-*l*59.9%
Applied egg-rr59.9%
*-lft-identity59.9%
associate-*r*56.7%
*-commutative56.7%
associate-*r*59.5%
Simplified59.5%
Taylor expanded in t around 0 58.2%
associate-/l*59.0%
+-commutative59.0%
*-commutative59.0%
associate-*r*60.3%
*-commutative60.3%
Simplified60.3%
Final simplification59.4%
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(/
(* (* n 2.0) (* U (* l l)))
(/ Om (- -2.0 (* (- U U*) (/ n Om))))))))
(if (<= l -3.2e-17)
t_1
(if (<= l 5.3e-135)
(pow (* 2.0 (* n (* U t))) 0.5)
(if (<= l 2.25e-39)
(sqrt (* 2.0 (* (* n U) (+ t (* -2.0 (/ (* l l) Om))))))
(if (<= l 3.8e+44)
(sqrt (* (* n 2.0) (- (* U t) (* 2.0 (/ (* l l) (/ Om U))))))
t_1))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt((((n * 2.0) * (U * (l * l))) / (Om / (-2.0 - ((U - U_42_) * (n / Om))))));
double tmp;
if (l <= -3.2e-17) {
tmp = t_1;
} else if (l <= 5.3e-135) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else if (l <= 2.25e-39) {
tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else if (l <= 3.8e+44) {
tmp = sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U))))));
} else {
tmp = t_1;
}
return tmp;
}
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((((n * 2.0d0) * (u * (l * l))) / (om / ((-2.0d0) - ((u - u_42) * (n / om))))))
if (l <= (-3.2d-17)) then
tmp = t_1
else if (l <= 5.3d-135) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else if (l <= 2.25d-39) then
tmp = sqrt((2.0d0 * ((n * u) * (t + ((-2.0d0) * ((l * l) / om))))))
else if (l <= 3.8d+44) then
tmp = sqrt(((n * 2.0d0) * ((u * t) - (2.0d0 * ((l * l) / (om / u))))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt((((n * 2.0) * (U * (l * l))) / (Om / (-2.0 - ((U - U_42_) * (n / Om))))));
double tmp;
if (l <= -3.2e-17) {
tmp = t_1;
} else if (l <= 5.3e-135) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else if (l <= 2.25e-39) {
tmp = Math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else if (l <= 3.8e+44) {
tmp = Math.sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U))))));
} else {
tmp = t_1;
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt((((n * 2.0) * (U * (l * l))) / (Om / (-2.0 - ((U - U_42_) * (n / Om)))))) tmp = 0 if l <= -3.2e-17: tmp = t_1 elif l <= 5.3e-135: tmp = math.pow((2.0 * (n * (U * t))), 0.5) elif l <= 2.25e-39: tmp = math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))) elif l <= 3.8e+44: tmp = math.sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U)))))) else: tmp = t_1 return tmp
function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(Float64(n * 2.0) * Float64(U * Float64(l * l))) / Float64(Om / Float64(-2.0 - Float64(Float64(U - U_42_) * Float64(n / Om)))))) tmp = 0.0 if (l <= -3.2e-17) tmp = t_1; elseif (l <= 5.3e-135) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; elseif (l <= 2.25e-39) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(-2.0 * Float64(Float64(l * l) / Om)))))); elseif (l <= 3.8e+44) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(U * t) - Float64(2.0 * Float64(Float64(l * l) / Float64(Om / U)))))); else tmp = t_1; end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt((((n * 2.0) * (U * (l * l))) / (Om / (-2.0 - ((U - U_42_) * (n / Om)))))); tmp = 0.0; if (l <= -3.2e-17) tmp = t_1; elseif (l <= 5.3e-135) tmp = (2.0 * (n * (U * t))) ^ 0.5; elseif (l <= 2.25e-39) tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))); elseif (l <= 3.8e+44) tmp = sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U)))))); else tmp = t_1; end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(N[(n * 2.0), $MachinePrecision] * N[(U * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(Om / N[(-2.0 - N[(N[(U - U$42$), $MachinePrecision] * N[(n / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, -3.2e-17], t$95$1, If[LessEqual[l, 5.3e-135], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], If[LessEqual[l, 2.25e-39], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.8e+44], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(U * t), $MachinePrecision] - N[(2.0 * N[(N[(l * l), $MachinePrecision] / N[(Om / U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{\frac{\left(n \cdot 2\right) \cdot \left(U \cdot \left(\ell \cdot \ell\right)\right)}{\frac{Om}{-2 - \left(U - U*\right) \cdot \frac{n}{Om}}}}\\
\mathbf{if}\;\ell \leq -3.2 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq 5.3 \cdot 10^{-135}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{elif}\;\ell \leq 2.25 \cdot 10^{-39}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + -2 \cdot \frac{\ell \cdot \ell}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.8 \cdot 10^{+44}:\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot t - 2 \cdot \frac{\ell \cdot \ell}{\frac{Om}{U}}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if l < -3.2000000000000002e-17 or 3.8000000000000002e44 < l Initial program 36.6%
associate-*l*34.9%
sub-neg34.9%
associate--l+34.9%
*-commutative34.9%
distribute-rgt-neg-in34.9%
associate-*l/43.2%
associate-*l*43.2%
*-commutative43.2%
*-commutative43.2%
associate-*l*42.8%
unpow242.8%
associate-*l*43.9%
Simplified51.7%
Taylor expanded in l around -inf 41.7%
associate-*r/41.7%
mul-1-neg41.7%
*-commutative41.7%
*-commutative41.7%
unpow241.7%
mul-1-neg41.7%
unsub-neg41.7%
associate-/l*41.7%
Simplified41.7%
*-un-lft-identity41.7%
associate-*l*41.7%
distribute-rgt-neg-in41.7%
associate-/r/41.7%
Applied egg-rr41.7%
*-lft-identity41.7%
associate-*r*41.7%
associate-/l*42.6%
unpow242.6%
*-commutative42.6%
associate-*r/42.7%
Simplified42.7%
if -3.2000000000000002e-17 < l < 5.3e-135Initial program 66.2%
associate-*l*69.8%
sub-neg69.8%
associate--l+69.8%
*-commutative69.8%
distribute-rgt-neg-in69.8%
associate-*l/69.8%
associate-*l*69.8%
*-commutative69.8%
*-commutative69.8%
associate-*l*61.6%
unpow261.6%
associate-*l*62.6%
Simplified62.6%
Taylor expanded in t around inf 61.6%
pow1/262.6%
associate-*l*62.6%
*-commutative62.6%
Applied egg-rr62.6%
if 5.3e-135 < l < 2.25e-39Initial program 56.5%
associate-*l*45.3%
sub-neg45.3%
associate--l+45.3%
*-commutative45.3%
distribute-rgt-neg-in45.3%
associate-*l/45.3%
associate-*l*45.3%
*-commutative45.3%
*-commutative45.3%
associate-*l*40.9%
unpow240.9%
associate-*l*41.3%
Simplified41.3%
*-un-lft-identity41.3%
associate-*l*41.3%
Applied egg-rr41.3%
*-lft-identity41.3%
associate-*r*52.6%
*-commutative52.6%
associate-*r*56.6%
Simplified56.6%
Taylor expanded in n around 0 48.6%
unpow248.6%
Simplified48.6%
if 2.25e-39 < l < 3.8000000000000002e44Initial program 55.3%
associate-*l*55.9%
sub-neg55.9%
associate--l+55.9%
*-commutative55.9%
distribute-rgt-neg-in55.9%
associate-*l/55.9%
associate-*l*55.9%
*-commutative55.9%
*-commutative55.9%
associate-*l*55.7%
unpow255.7%
associate-*l*62.4%
Simplified62.4%
Taylor expanded in l around -inf 61.8%
mul-1-neg61.8%
unsub-neg61.8%
*-commutative61.8%
associate-/l*61.8%
mul-1-neg61.8%
unsub-neg61.8%
associate-/l*61.8%
*-commutative61.8%
unpow261.8%
Simplified61.8%
Taylor expanded in n around 0 47.7%
associate-/l*47.9%
unpow247.9%
Simplified47.9%
Final simplification52.0%
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(*
(* n 2.0)
(/ (* (* l (* U l)) (- (/ n (/ Om (- U* U))) 2.0)) Om)))))
(if (<= l -1.55e-17)
t_1
(if (<= l 1.1e-136)
(pow (* 2.0 (* n (* U t))) 0.5)
(if (<= l 7.3e-40)
(sqrt (* 2.0 (* (* n U) (+ t (* -2.0 (/ (* l l) Om))))))
(if (<= l 8e+44)
(sqrt (* (* n 2.0) (- (* U t) (* 2.0 (/ (* l l) (/ Om U))))))
t_1))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((n * 2.0) * (((l * (U * l)) * ((n / (Om / (U_42_ - U))) - 2.0)) / Om)));
double tmp;
if (l <= -1.55e-17) {
tmp = t_1;
} else if (l <= 1.1e-136) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else if (l <= 7.3e-40) {
tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else if (l <= 8e+44) {
tmp = sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U))))));
} else {
tmp = t_1;
}
return tmp;
}
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(((n * 2.0d0) * (((l * (u * l)) * ((n / (om / (u_42 - u))) - 2.0d0)) / om)))
if (l <= (-1.55d-17)) then
tmp = t_1
else if (l <= 1.1d-136) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else if (l <= 7.3d-40) then
tmp = sqrt((2.0d0 * ((n * u) * (t + ((-2.0d0) * ((l * l) / om))))))
else if (l <= 8d+44) then
tmp = sqrt(((n * 2.0d0) * ((u * t) - (2.0d0 * ((l * l) / (om / u))))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((n * 2.0) * (((l * (U * l)) * ((n / (Om / (U_42_ - U))) - 2.0)) / Om)));
double tmp;
if (l <= -1.55e-17) {
tmp = t_1;
} else if (l <= 1.1e-136) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else if (l <= 7.3e-40) {
tmp = Math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else if (l <= 8e+44) {
tmp = Math.sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U))))));
} else {
tmp = t_1;
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((n * 2.0) * (((l * (U * l)) * ((n / (Om / (U_42_ - U))) - 2.0)) / Om))) tmp = 0 if l <= -1.55e-17: tmp = t_1 elif l <= 1.1e-136: tmp = math.pow((2.0 * (n * (U * t))), 0.5) elif l <= 7.3e-40: tmp = math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))) elif l <= 8e+44: tmp = math.sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U)))))) else: tmp = t_1 return tmp
function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(Float64(l * Float64(U * l)) * Float64(Float64(n / Float64(Om / Float64(U_42_ - U))) - 2.0)) / Om))) tmp = 0.0 if (l <= -1.55e-17) tmp = t_1; elseif (l <= 1.1e-136) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; elseif (l <= 7.3e-40) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(-2.0 * Float64(Float64(l * l) / Om)))))); elseif (l <= 8e+44) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(U * t) - Float64(2.0 * Float64(Float64(l * l) / Float64(Om / U)))))); else tmp = t_1; end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((n * 2.0) * (((l * (U * l)) * ((n / (Om / (U_42_ - U))) - 2.0)) / Om))); tmp = 0.0; if (l <= -1.55e-17) tmp = t_1; elseif (l <= 1.1e-136) tmp = (2.0 * (n * (U * t))) ^ 0.5; elseif (l <= 7.3e-40) tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))); elseif (l <= 8e+44) tmp = sqrt(((n * 2.0) * ((U * t) - (2.0 * ((l * l) / (Om / U)))))); else tmp = t_1; end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(N[(l * N[(U * l), $MachinePrecision]), $MachinePrecision] * N[(N[(n / N[(Om / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, -1.55e-17], t$95$1, If[LessEqual[l, 1.1e-136], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], If[LessEqual[l, 7.3e-40], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 8e+44], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(U * t), $MachinePrecision] - N[(2.0 * N[(N[(l * l), $MachinePrecision] / N[(Om / U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{\left(n \cdot 2\right) \cdot \frac{\left(\ell \cdot \left(U \cdot \ell\right)\right) \cdot \left(\frac{n}{\frac{Om}{U* - U}} - 2\right)}{Om}}\\
\mathbf{if}\;\ell \leq -1.55 \cdot 10^{-17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq 1.1 \cdot 10^{-136}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{elif}\;\ell \leq 7.3 \cdot 10^{-40}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + -2 \cdot \frac{\ell \cdot \ell}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 8 \cdot 10^{+44}:\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot t - 2 \cdot \frac{\ell \cdot \ell}{\frac{Om}{U}}\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if l < -1.5499999999999999e-17 or 8.0000000000000007e44 < l Initial program 36.6%
associate-*l*34.9%
sub-neg34.9%
associate--l+34.9%
*-commutative34.9%
distribute-rgt-neg-in34.9%
associate-*l/43.2%
associate-*l*43.2%
*-commutative43.2%
*-commutative43.2%
associate-*l*42.8%
unpow242.8%
associate-*l*43.9%
Simplified51.7%
Taylor expanded in l around -inf 41.7%
associate-*r/41.7%
mul-1-neg41.7%
*-commutative41.7%
*-commutative41.7%
unpow241.7%
mul-1-neg41.7%
unsub-neg41.7%
associate-/l*41.7%
Simplified41.7%
Taylor expanded in U around 0 41.7%
*-commutative41.7%
unpow241.7%
associate-*l*44.5%
*-commutative44.5%
*-commutative44.5%
Simplified44.5%
if -1.5499999999999999e-17 < l < 1.1000000000000001e-136Initial program 66.2%
associate-*l*69.8%
sub-neg69.8%
associate--l+69.8%
*-commutative69.8%
distribute-rgt-neg-in69.8%
associate-*l/69.8%
associate-*l*69.8%
*-commutative69.8%
*-commutative69.8%
associate-*l*61.6%
unpow261.6%
associate-*l*62.6%
Simplified62.6%
Taylor expanded in t around inf 61.6%
pow1/262.6%
associate-*l*62.6%
*-commutative62.6%
Applied egg-rr62.6%
if 1.1000000000000001e-136 < l < 7.30000000000000005e-40Initial program 56.5%
associate-*l*45.3%
sub-neg45.3%
associate--l+45.3%
*-commutative45.3%
distribute-rgt-neg-in45.3%
associate-*l/45.3%
associate-*l*45.3%
*-commutative45.3%
*-commutative45.3%
associate-*l*40.9%
unpow240.9%
associate-*l*41.3%
Simplified41.3%
*-un-lft-identity41.3%
associate-*l*41.3%
Applied egg-rr41.3%
*-lft-identity41.3%
associate-*r*52.6%
*-commutative52.6%
associate-*r*56.6%
Simplified56.6%
Taylor expanded in n around 0 48.6%
unpow248.6%
Simplified48.6%
if 7.30000000000000005e-40 < l < 8.0000000000000007e44Initial program 55.3%
associate-*l*55.9%
sub-neg55.9%
associate--l+55.9%
*-commutative55.9%
distribute-rgt-neg-in55.9%
associate-*l/55.9%
associate-*l*55.9%
*-commutative55.9%
*-commutative55.9%
associate-*l*55.7%
unpow255.7%
associate-*l*62.4%
Simplified62.4%
Taylor expanded in l around -inf 61.8%
mul-1-neg61.8%
unsub-neg61.8%
*-commutative61.8%
associate-/l*61.8%
mul-1-neg61.8%
unsub-neg61.8%
associate-/l*61.8%
*-commutative61.8%
unpow261.8%
Simplified61.8%
Taylor expanded in n around 0 47.7%
associate-/l*47.9%
unpow247.9%
Simplified47.9%
Final simplification52.7%
(FPCore (n U t l Om U*)
:precision binary64
(if (or (<= n -1.75e-37) (not (<= n 5.2e-58)))
(sqrt (* (* n 2.0) (+ (* U t) (/ (* (* n (* l l)) (* U U*)) (* Om Om)))))
(sqrt
(*
2.0
(* U (* n (+ t (/ l (/ Om (- (* l -2.0) (/ n (/ Om (* U l)))))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.75e-37) || !(n <= 5.2e-58)) {
tmp = sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om)))));
} else {
tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l)))))))))));
}
return tmp;
}
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 ((n <= (-1.75d-37)) .or. (.not. (n <= 5.2d-58))) then
tmp = sqrt(((n * 2.0d0) * ((u * t) + (((n * (l * l)) * (u * u_42)) / (om * om)))))
else
tmp = sqrt((2.0d0 * (u * (n * (t + (l / (om / ((l * (-2.0d0)) - (n / (om / (u * l)))))))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.75e-37) || !(n <= 5.2e-58)) {
tmp = Math.sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om)))));
} else {
tmp = Math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l)))))))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if (n <= -1.75e-37) or not (n <= 5.2e-58): tmp = math.sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om))))) else: tmp = math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l))))))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((n <= -1.75e-37) || !(n <= 5.2e-58)) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(U * t) + Float64(Float64(Float64(n * Float64(l * l)) * Float64(U * U_42_)) / Float64(Om * Om))))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(t + Float64(l / Float64(Om / Float64(Float64(l * -2.0) - Float64(n / Float64(Om / Float64(U * l))))))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if ((n <= -1.75e-37) || ~((n <= 5.2e-58))) tmp = sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om))))); else tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - (n / (Om / (U * l))))))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[n, -1.75e-37], N[Not[LessEqual[n, 5.2e-58]], $MachinePrecision]], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(U * t), $MachinePrecision] + N[(N[(N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(U * U$42$), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * 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]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.75 \cdot 10^{-37} \lor \neg \left(n \leq 5.2 \cdot 10^{-58}\right):\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot t + \frac{\left(n \cdot \left(\ell \cdot \ell\right)\right) \cdot \left(U \cdot U*\right)}{Om \cdot Om}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(t + \frac{\ell}{\frac{Om}{\ell \cdot -2 - \frac{n}{\frac{Om}{U \cdot \ell}}}}\right)\right)\right)}\\
\end{array}
\end{array}
if n < -1.7500000000000001e-37 or 5.20000000000000013e-58 < n Initial program 56.8%
associate-*l*57.1%
sub-neg57.1%
associate--l+57.1%
*-commutative57.1%
distribute-rgt-neg-in57.1%
associate-*l/57.1%
associate-*l*57.1%
*-commutative57.1%
*-commutative57.1%
associate-*l*50.2%
unpow250.2%
associate-*l*50.4%
Simplified55.8%
Taylor expanded in l around -inf 50.2%
mul-1-neg50.2%
unsub-neg50.2%
*-commutative50.2%
associate-/l*50.2%
mul-1-neg50.2%
unsub-neg50.2%
associate-/l*53.7%
*-commutative53.7%
unpow253.7%
Simplified53.7%
Taylor expanded in U* around inf 50.7%
associate-*r/50.7%
mul-1-neg50.7%
associate-*r*49.3%
unpow249.3%
*-commutative49.3%
unpow249.3%
Simplified49.3%
if -1.7500000000000001e-37 < n < 5.20000000000000013e-58Initial program 45.6%
associate-*l*44.6%
sub-neg44.6%
associate--l+44.6%
*-commutative44.6%
distribute-rgt-neg-in44.6%
associate-*l/53.0%
associate-*l*53.0%
*-commutative53.0%
*-commutative53.0%
associate-*l*52.9%
unpow252.9%
associate-*l*55.8%
Simplified56.0%
*-un-lft-identity56.0%
associate-*l*56.0%
Applied egg-rr56.0%
*-lft-identity56.0%
associate-*r*55.5%
*-commutative55.5%
associate-*r*55.5%
Simplified55.5%
Taylor expanded in U* around 0 42.1%
associate-*r*44.2%
associate-/l*53.4%
+-commutative53.4%
mul-1-neg53.4%
unsub-neg53.4%
*-commutative53.4%
associate-/l*53.3%
Simplified53.3%
Final simplification51.0%
(FPCore (n U t l Om U*)
:precision binary64
(if (or (<= n -1.78e-37) (not (<= n 2.85e-58)))
(sqrt (* (* n 2.0) (+ (* U t) (/ (* (* n (* l l)) (* U U*)) (* Om Om)))))
(sqrt
(*
2.0
(* U (* n (+ t (/ l (/ Om (- (* l -2.0) (/ (* U (* n l)) Om)))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.78e-37) || !(n <= 2.85e-58)) {
tmp = sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om)))));
} else {
tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
}
return tmp;
}
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 ((n <= (-1.78d-37)) .or. (.not. (n <= 2.85d-58))) then
tmp = sqrt(((n * 2.0d0) * ((u * t) + (((n * (l * l)) * (u * u_42)) / (om * om)))))
else
tmp = sqrt((2.0d0 * (u * (n * (t + (l / (om / ((l * (-2.0d0)) - ((u * (n * l)) / om)))))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.78e-37) || !(n <= 2.85e-58)) {
tmp = Math.sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om)))));
} else {
tmp = Math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if (n <= -1.78e-37) or not (n <= 2.85e-58): tmp = math.sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om))))) else: tmp = math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((n <= -1.78e-37) || !(n <= 2.85e-58)) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(U * t) + Float64(Float64(Float64(n * Float64(l * l)) * Float64(U * U_42_)) / Float64(Om * Om))))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(t + Float64(l / Float64(Om / Float64(Float64(l * -2.0) - Float64(Float64(U * Float64(n * l)) / Om))))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if ((n <= -1.78e-37) || ~((n <= 2.85e-58))) tmp = sqrt(((n * 2.0) * ((U * t) + (((n * (l * l)) * (U * U_42_)) / (Om * Om))))); else tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[n, -1.78e-37], N[Not[LessEqual[n, 2.85e-58]], $MachinePrecision]], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(U * t), $MachinePrecision] + N[(N[(N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(U * U$42$), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t + N[(l / N[(Om / N[(N[(l * -2.0), $MachinePrecision] - N[(N[(U * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.78 \cdot 10^{-37} \lor \neg \left(n \leq 2.85 \cdot 10^{-58}\right):\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot t + \frac{\left(n \cdot \left(\ell \cdot \ell\right)\right) \cdot \left(U \cdot U*\right)}{Om \cdot Om}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(t + \frac{\ell}{\frac{Om}{\ell \cdot -2 - \frac{U \cdot \left(n \cdot \ell\right)}{Om}}}\right)\right)\right)}\\
\end{array}
\end{array}
if n < -1.78000000000000005e-37 or 2.85000000000000016e-58 < n Initial program 56.8%
associate-*l*57.1%
sub-neg57.1%
associate--l+57.1%
*-commutative57.1%
distribute-rgt-neg-in57.1%
associate-*l/57.1%
associate-*l*57.1%
*-commutative57.1%
*-commutative57.1%
associate-*l*50.2%
unpow250.2%
associate-*l*50.4%
Simplified55.8%
Taylor expanded in l around -inf 50.2%
mul-1-neg50.2%
unsub-neg50.2%
*-commutative50.2%
associate-/l*50.2%
mul-1-neg50.2%
unsub-neg50.2%
associate-/l*53.7%
*-commutative53.7%
unpow253.7%
Simplified53.7%
Taylor expanded in U* around inf 50.7%
associate-*r/50.7%
mul-1-neg50.7%
associate-*r*49.3%
unpow249.3%
*-commutative49.3%
unpow249.3%
Simplified49.3%
if -1.78000000000000005e-37 < n < 2.85000000000000016e-58Initial program 45.6%
associate-*l*44.6%
sub-neg44.6%
associate--l+44.6%
*-commutative44.6%
distribute-rgt-neg-in44.6%
associate-*l/53.0%
associate-*l*53.0%
*-commutative53.0%
*-commutative53.0%
associate-*l*52.9%
unpow252.9%
associate-*l*55.8%
Simplified56.0%
Taylor expanded in U* around 0 42.1%
associate-*r*44.2%
+-commutative44.2%
Simplified58.2%
Final simplification53.0%
(FPCore (n U t l Om U*)
:precision binary64
(if (or (<= n -1.9e-230) (not (<= n 2e-58)))
(sqrt
(*
(* n 2.0)
(* U (+ t (/ (* l (+ (* l -2.0) (/ (* n (* l U*)) Om))) Om)))))
(sqrt
(*
2.0
(* U (* n (+ t (/ l (/ Om (- (* l -2.0) (/ (* U (* n l)) Om)))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.9e-230) || !(n <= 2e-58)) {
tmp = sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om)))));
} else {
tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
}
return tmp;
}
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 ((n <= (-1.9d-230)) .or. (.not. (n <= 2d-58))) then
tmp = sqrt(((n * 2.0d0) * (u * (t + ((l * ((l * (-2.0d0)) + ((n * (l * u_42)) / om))) / om)))))
else
tmp = sqrt((2.0d0 * (u * (n * (t + (l / (om / ((l * (-2.0d0)) - ((u * (n * l)) / om)))))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((n <= -1.9e-230) || !(n <= 2e-58)) {
tmp = Math.sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om)))));
} else {
tmp = Math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om)))))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if (n <= -1.9e-230) or not (n <= 2e-58): tmp = math.sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om))))) else: tmp = math.sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((n <= -1.9e-230) || !(n <= 2e-58)) tmp = sqrt(Float64(Float64(n * 2.0) * Float64(U * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + Float64(Float64(n * Float64(l * U_42_)) / Om))) / Om))))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(t + Float64(l / Float64(Om / Float64(Float64(l * -2.0) - Float64(Float64(U * Float64(n * l)) / Om))))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if ((n <= -1.9e-230) || ~((n <= 2e-58))) tmp = sqrt(((n * 2.0) * (U * (t + ((l * ((l * -2.0) + ((n * (l * U_42_)) / Om))) / Om))))); else tmp = sqrt((2.0 * (U * (n * (t + (l / (Om / ((l * -2.0) - ((U * (n * l)) / Om))))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[n, -1.9e-230], N[Not[LessEqual[n, 2e-58]], $MachinePrecision]], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(U * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + N[(N[(n * N[(l * U$42$), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t + N[(l / N[(Om / N[(N[(l * -2.0), $MachinePrecision] - N[(N[(U * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;n \leq -1.9 \cdot 10^{-230} \lor \neg \left(n \leq 2 \cdot 10^{-58}\right):\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + \frac{n \cdot \left(\ell \cdot U*\right)}{Om}\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(t + \frac{\ell}{\frac{Om}{\ell \cdot -2 - \frac{U \cdot \left(n \cdot \ell\right)}{Om}}}\right)\right)\right)}\\
\end{array}
\end{array}
if n < -1.8999999999999999e-230 or 2.0000000000000001e-58 < n Initial program 55.6%
associate-*l*58.0%
sub-neg58.0%
associate--l+58.0%
*-commutative58.0%
distribute-rgt-neg-in58.0%
associate-*l/59.0%
associate-*l*59.0%
*-commutative59.0%
*-commutative59.0%
associate-*l*53.4%
unpow253.4%
associate-*l*53.6%
Simplified58.0%
Taylor expanded in U around 0 60.8%
if -1.8999999999999999e-230 < n < 2.0000000000000001e-58Initial program 43.2%
associate-*l*36.2%
sub-neg36.2%
associate--l+36.2%
*-commutative36.2%
distribute-rgt-neg-in36.2%
associate-*l/46.0%
associate-*l*46.0%
*-commutative46.0%
*-commutative46.0%
associate-*l*45.9%
unpow245.9%
associate-*l*50.2%
Simplified50.3%
Taylor expanded in U* around 0 37.6%
associate-*r*41.8%
+-commutative41.8%
Simplified58.6%
Final simplification60.2%
(FPCore (n U t l Om U*)
:precision binary64
(if (<= t -5e+161)
(pow (* 2.0 (* n (* U t))) 0.5)
(if (or (<= t -8.5e-12) (not (<= t -1.8e-52)))
(sqrt (* 2.0 (* (* n U) (+ t (* -2.0 (/ (* l l) Om))))))
(sqrt
(* (* n 2.0) (/ (* l (- l)) (/ Om (* U (- 2.0 (/ n (/ Om U*)))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (t <= -5e+161) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else if ((t <= -8.5e-12) || !(t <= -1.8e-52)) {
tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else {
tmp = sqrt(((n * 2.0) * ((l * -l) / (Om / (U * (2.0 - (n / (Om / U_42_))))))));
}
return tmp;
}
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 (t <= (-5d+161)) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else if ((t <= (-8.5d-12)) .or. (.not. (t <= (-1.8d-52)))) then
tmp = sqrt((2.0d0 * ((n * u) * (t + ((-2.0d0) * ((l * l) / om))))))
else
tmp = sqrt(((n * 2.0d0) * ((l * -l) / (om / (u * (2.0d0 - (n / (om / u_42))))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (t <= -5e+161) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else if ((t <= -8.5e-12) || !(t <= -1.8e-52)) {
tmp = Math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else {
tmp = Math.sqrt(((n * 2.0) * ((l * -l) / (Om / (U * (2.0 - (n / (Om / U_42_))))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if t <= -5e+161: tmp = math.pow((2.0 * (n * (U * t))), 0.5) elif (t <= -8.5e-12) or not (t <= -1.8e-52): tmp = math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))) else: tmp = math.sqrt(((n * 2.0) * ((l * -l) / (Om / (U * (2.0 - (n / (Om / U_42_)))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (t <= -5e+161) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; elseif ((t <= -8.5e-12) || !(t <= -1.8e-52)) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(-2.0 * Float64(Float64(l * l) / Om)))))); else tmp = sqrt(Float64(Float64(n * 2.0) * Float64(Float64(l * Float64(-l)) / Float64(Om / Float64(U * Float64(2.0 - Float64(n / Float64(Om / U_42_)))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (t <= -5e+161) tmp = (2.0 * (n * (U * t))) ^ 0.5; elseif ((t <= -8.5e-12) || ~((t <= -1.8e-52))) tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))); else tmp = sqrt(((n * 2.0) * ((l * -l) / (Om / (U * (2.0 - (n / (Om / U_42_)))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[t, -5e+161], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], If[Or[LessEqual[t, -8.5e-12], N[Not[LessEqual[t, -1.8e-52]], $MachinePrecision]], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(N[(l * (-l)), $MachinePrecision] / N[(Om / N[(U * N[(2.0 - N[(n / N[(Om / U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5 \cdot 10^{+161}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{elif}\;t \leq -8.5 \cdot 10^{-12} \lor \neg \left(t \leq -1.8 \cdot 10^{-52}\right):\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + -2 \cdot \frac{\ell \cdot \ell}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \frac{\ell \cdot \left(-\ell\right)}{\frac{Om}{U \cdot \left(2 - \frac{n}{\frac{Om}{U*}}\right)}}}\\
\end{array}
\end{array}
if t < -4.9999999999999997e161Initial program 44.4%
associate-*l*51.8%
sub-neg51.8%
associate--l+51.8%
*-commutative51.8%
distribute-rgt-neg-in51.8%
associate-*l/61.0%
associate-*l*61.0%
*-commutative61.0%
*-commutative61.0%
associate-*l*57.2%
unpow257.2%
associate-*l*60.6%
Simplified67.0%
Taylor expanded in t around inf 61.0%
pow1/264.3%
associate-*l*64.3%
*-commutative64.3%
Applied egg-rr64.3%
if -4.9999999999999997e161 < t < -8.4999999999999997e-12 or -1.79999999999999994e-52 < t Initial program 53.4%
associate-*l*51.5%
sub-neg51.5%
associate--l+51.5%
*-commutative51.5%
distribute-rgt-neg-in51.5%
associate-*l/54.3%
associate-*l*54.3%
*-commutative54.3%
*-commutative54.3%
associate-*l*50.0%
unpow250.0%
associate-*l*51.0%
Simplified53.5%
*-un-lft-identity53.5%
associate-*l*53.5%
Applied egg-rr53.5%
*-lft-identity53.5%
associate-*r*56.7%
*-commutative56.7%
associate-*r*60.1%
Simplified60.1%
Taylor expanded in n around 0 45.1%
unpow245.1%
Simplified45.1%
if -8.4999999999999997e-12 < t < -1.79999999999999994e-52Initial program 51.8%
associate-*l*61.2%
sub-neg61.2%
associate--l+61.2%
*-commutative61.2%
distribute-rgt-neg-in61.2%
associate-*l/61.2%
associate-*l*61.2%
*-commutative61.2%
*-commutative61.2%
associate-*l*60.7%
unpow260.7%
associate-*l*61.5%
Simplified71.5%
Taylor expanded in l around -inf 61.1%
associate-*r/61.1%
mul-1-neg61.1%
*-commutative61.1%
*-commutative61.1%
unpow261.1%
mul-1-neg61.1%
unsub-neg61.1%
associate-/l*61.1%
Simplified61.1%
Taylor expanded in U around 0 80.5%
mul-1-neg80.5%
associate-/l*80.5%
unpow280.5%
*-commutative80.5%
associate-/l*80.0%
Simplified80.0%
Final simplification48.8%
(FPCore (n U t l Om U*)
:precision binary64
(if (<= t -1.3e+162)
(pow (* 2.0 (* n (* U t))) 0.5)
(if (or (<= t -2.75e-12) (not (<= t -5.2e-47)))
(sqrt (* 2.0 (* (* n U) (+ t (* -2.0 (/ (* l l) Om))))))
(sqrt (* (* n 2.0) (/ n (* (/ Om U) (/ Om (* U* (* l l))))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (t <= -1.3e+162) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else if ((t <= -2.75e-12) || !(t <= -5.2e-47)) {
tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else {
tmp = sqrt(((n * 2.0) * (n / ((Om / U) * (Om / (U_42_ * (l * l)))))));
}
return tmp;
}
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 (t <= (-1.3d+162)) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else if ((t <= (-2.75d-12)) .or. (.not. (t <= (-5.2d-47)))) then
tmp = sqrt((2.0d0 * ((n * u) * (t + ((-2.0d0) * ((l * l) / om))))))
else
tmp = sqrt(((n * 2.0d0) * (n / ((om / u) * (om / (u_42 * (l * l)))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (t <= -1.3e+162) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else if ((t <= -2.75e-12) || !(t <= -5.2e-47)) {
tmp = Math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
} else {
tmp = Math.sqrt(((n * 2.0) * (n / ((Om / U) * (Om / (U_42_ * (l * l)))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if t <= -1.3e+162: tmp = math.pow((2.0 * (n * (U * t))), 0.5) elif (t <= -2.75e-12) or not (t <= -5.2e-47): tmp = math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))) else: tmp = math.sqrt(((n * 2.0) * (n / ((Om / U) * (Om / (U_42_ * (l * l))))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (t <= -1.3e+162) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; elseif ((t <= -2.75e-12) || !(t <= -5.2e-47)) tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(-2.0 * Float64(Float64(l * l) / Om)))))); else tmp = sqrt(Float64(Float64(n * 2.0) * Float64(n / Float64(Float64(Om / U) * Float64(Om / Float64(U_42_ * Float64(l * l))))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (t <= -1.3e+162) tmp = (2.0 * (n * (U * t))) ^ 0.5; elseif ((t <= -2.75e-12) || ~((t <= -5.2e-47))) tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))); else tmp = sqrt(((n * 2.0) * (n / ((Om / U) * (Om / (U_42_ * (l * l))))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[t, -1.3e+162], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], If[Or[LessEqual[t, -2.75e-12], N[Not[LessEqual[t, -5.2e-47]], $MachinePrecision]], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(n / N[(N[(Om / U), $MachinePrecision] * N[(Om / N[(U$42$ * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.3 \cdot 10^{+162}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{elif}\;t \leq -2.75 \cdot 10^{-12} \lor \neg \left(t \leq -5.2 \cdot 10^{-47}\right):\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + -2 \cdot \frac{\ell \cdot \ell}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(n \cdot 2\right) \cdot \frac{n}{\frac{Om}{U} \cdot \frac{Om}{U* \cdot \left(\ell \cdot \ell\right)}}}\\
\end{array}
\end{array}
if t < -1.3e162Initial program 44.4%
associate-*l*51.8%
sub-neg51.8%
associate--l+51.8%
*-commutative51.8%
distribute-rgt-neg-in51.8%
associate-*l/61.0%
associate-*l*61.0%
*-commutative61.0%
*-commutative61.0%
associate-*l*57.2%
unpow257.2%
associate-*l*60.6%
Simplified67.0%
Taylor expanded in t around inf 61.0%
pow1/264.3%
associate-*l*64.3%
*-commutative64.3%
Applied egg-rr64.3%
if -1.3e162 < t < -2.7500000000000002e-12 or -5.2e-47 < t Initial program 53.6%
associate-*l*51.8%
sub-neg51.8%
associate--l+51.8%
*-commutative51.8%
distribute-rgt-neg-in51.8%
associate-*l/54.5%
associate-*l*54.5%
*-commutative54.5%
*-commutative54.5%
associate-*l*50.2%
unpow250.2%
associate-*l*51.2%
Simplified53.7%
*-un-lft-identity53.7%
associate-*l*53.7%
Applied egg-rr53.7%
*-lft-identity53.7%
associate-*r*56.9%
*-commutative56.9%
associate-*r*60.3%
Simplified60.3%
Taylor expanded in n around 0 44.9%
unpow244.9%
Simplified44.9%
if -2.7500000000000002e-12 < t < -5.2e-47Initial program 46.5%
associate-*l*56.9%
sub-neg56.9%
associate--l+56.9%
*-commutative56.9%
distribute-rgt-neg-in56.9%
associate-*l/56.9%
associate-*l*56.9%
*-commutative56.9%
*-commutative56.9%
associate-*l*56.4%
unpow256.4%
associate-*l*57.2%
Simplified68.3%
Taylor expanded in l around -inf 56.8%
associate-*r/56.8%
mul-1-neg56.8%
*-commutative56.8%
*-commutative56.8%
unpow256.8%
mul-1-neg56.8%
unsub-neg56.8%
associate-/l*56.8%
Simplified56.8%
Taylor expanded in U* around inf 57.0%
associate-/l*56.8%
unpow256.8%
associate-*r*56.8%
times-frac67.8%
unpow267.8%
Simplified67.8%
Final simplification48.1%
(FPCore (n U t l Om U*) :precision binary64 (if (or (<= l -8800.0) (not (<= l 2.3e+45))) (pow (* 2.0 (* n (* -2.0 (* U (/ (* l l) Om))))) 0.5) (pow (* 2.0 (* n (* U t))) 0.5)))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((l <= -8800.0) || !(l <= 2.3e+45)) {
tmp = pow((2.0 * (n * (-2.0 * (U * ((l * l) / Om))))), 0.5);
} else {
tmp = pow((2.0 * (n * (U * t))), 0.5);
}
return tmp;
}
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 <= (-8800.0d0)) .or. (.not. (l <= 2.3d+45))) then
tmp = (2.0d0 * (n * ((-2.0d0) * (u * ((l * l) / om))))) ** 0.5d0
else
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((l <= -8800.0) || !(l <= 2.3e+45)) {
tmp = Math.pow((2.0 * (n * (-2.0 * (U * ((l * l) / Om))))), 0.5);
} else {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if (l <= -8800.0) or not (l <= 2.3e+45): tmp = math.pow((2.0 * (n * (-2.0 * (U * ((l * l) / Om))))), 0.5) else: tmp = math.pow((2.0 * (n * (U * t))), 0.5) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((l <= -8800.0) || !(l <= 2.3e+45)) tmp = Float64(2.0 * Float64(n * Float64(-2.0 * Float64(U * Float64(Float64(l * l) / Om))))) ^ 0.5; else tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if ((l <= -8800.0) || ~((l <= 2.3e+45))) tmp = (2.0 * (n * (-2.0 * (U * ((l * l) / Om))))) ^ 0.5; else tmp = (2.0 * (n * (U * t))) ^ 0.5; end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[l, -8800.0], N[Not[LessEqual[l, 2.3e+45]], $MachinePrecision]], N[Power[N[(2.0 * N[(n * N[(-2.0 * N[(U * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -8800 \lor \neg \left(\ell \leq 2.3 \cdot 10^{+45}\right):\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(-2 \cdot \left(U \cdot \frac{\ell \cdot \ell}{Om}\right)\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\end{array}
\end{array}
if l < -8800 or 2.30000000000000012e45 < l Initial program 35.6%
associate-*l*33.8%
sub-neg33.8%
associate--l+33.8%
*-commutative33.8%
distribute-rgt-neg-in33.8%
associate-*l/42.6%
associate-*l*42.6%
*-commutative42.6%
*-commutative42.6%
associate-*l*42.2%
unpow242.2%
associate-*l*43.3%
Simplified51.6%
Taylor expanded in l around inf 36.1%
associate-*r*34.1%
unpow234.1%
associate-/l*34.3%
unpow234.3%
associate-*r/34.3%
metadata-eval34.3%
Simplified34.3%
Taylor expanded in U* around 0 10.8%
unpow210.8%
*-commutative10.8%
mul-1-neg10.8%
associate-/l*10.9%
unpow210.9%
associate-*r/10.9%
metadata-eval10.9%
Simplified10.9%
Taylor expanded in U around 0 24.7%
associate-/l*21.8%
unpow221.8%
Simplified21.8%
pow1/229.9%
associate-/r/32.8%
Applied egg-rr32.8%
if -8800 < l < 2.30000000000000012e45Initial program 63.0%
associate-*l*63.8%
sub-neg63.8%
associate--l+63.8%
*-commutative63.8%
distribute-rgt-neg-in63.8%
associate-*l/63.8%
associate-*l*63.8%
*-commutative63.8%
*-commutative63.8%
associate-*l*57.3%
unpow257.3%
associate-*l*58.7%
Simplified58.7%
Taylor expanded in t around inf 51.5%
pow1/252.3%
associate-*l*52.3%
*-commutative52.3%
Applied egg-rr52.3%
Final simplification44.6%
(FPCore (n U t l Om U*) :precision binary64 (if (or (<= l -5800.0) (not (<= l 7.2e+50))) (sqrt (* 2.0 (* -2.0 (/ n (/ Om (* U (* l l))))))) (pow (* 2.0 (* n (* U t))) 0.5)))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((l <= -5800.0) || !(l <= 7.2e+50)) {
tmp = sqrt((2.0 * (-2.0 * (n / (Om / (U * (l * l)))))));
} else {
tmp = pow((2.0 * (n * (U * t))), 0.5);
}
return tmp;
}
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 <= (-5800.0d0)) .or. (.not. (l <= 7.2d+50))) then
tmp = sqrt((2.0d0 * ((-2.0d0) * (n / (om / (u * (l * l)))))))
else
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((l <= -5800.0) || !(l <= 7.2e+50)) {
tmp = Math.sqrt((2.0 * (-2.0 * (n / (Om / (U * (l * l)))))));
} else {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if (l <= -5800.0) or not (l <= 7.2e+50): tmp = math.sqrt((2.0 * (-2.0 * (n / (Om / (U * (l * l))))))) else: tmp = math.pow((2.0 * (n * (U * t))), 0.5) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((l <= -5800.0) || !(l <= 7.2e+50)) tmp = sqrt(Float64(2.0 * Float64(-2.0 * Float64(n / Float64(Om / Float64(U * Float64(l * l))))))); else tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if ((l <= -5800.0) || ~((l <= 7.2e+50))) tmp = sqrt((2.0 * (-2.0 * (n / (Om / (U * (l * l))))))); else tmp = (2.0 * (n * (U * t))) ^ 0.5; end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[l, -5800.0], N[Not[LessEqual[l, 7.2e+50]], $MachinePrecision]], N[Sqrt[N[(2.0 * N[(-2.0 * N[(n / N[(Om / N[(U * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -5800 \lor \neg \left(\ell \leq 7.2 \cdot 10^{+50}\right):\\
\;\;\;\;\sqrt{2 \cdot \left(-2 \cdot \frac{n}{\frac{Om}{U \cdot \left(\ell \cdot \ell\right)}}\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\end{array}
\end{array}
if l < -5800 or 7.19999999999999972e50 < l Initial program 35.6%
associate-*l*33.8%
sub-neg33.8%
associate--l+33.8%
*-commutative33.8%
distribute-rgt-neg-in33.8%
associate-*l/42.8%
associate-*l*42.8%
*-commutative42.8%
*-commutative42.8%
associate-*l*42.4%
unpow242.4%
associate-*l*43.6%
Simplified51.1%
Taylor expanded in l around inf 36.1%
associate-*r*34.0%
unpow234.0%
associate-/l*34.3%
unpow234.3%
associate-*r/34.3%
metadata-eval34.3%
Simplified34.3%
Taylor expanded in U* around 0 11.1%
unpow211.1%
*-commutative11.1%
mul-1-neg11.1%
associate-/l*11.2%
unpow211.2%
associate-*r/11.2%
metadata-eval11.2%
Simplified11.2%
Taylor expanded in U around 0 25.3%
associate-/l*22.4%
unpow222.4%
Simplified22.4%
Taylor expanded in n around 0 25.5%
associate-/l*24.5%
*-commutative24.5%
unpow224.5%
Simplified24.5%
if -5800 < l < 7.19999999999999972e50Initial program 62.5%
associate-*l*63.2%
sub-neg63.2%
associate--l+63.2%
*-commutative63.2%
distribute-rgt-neg-in63.2%
associate-*l/63.2%
associate-*l*63.2%
*-commutative63.2%
*-commutative63.2%
associate-*l*56.8%
unpow256.8%
associate-*l*58.2%
Simplified58.9%
Taylor expanded in t around inf 51.2%
pow1/251.9%
associate-*l*51.9%
*-commutative51.9%
Applied egg-rr51.9%
Final simplification41.4%
(FPCore (n U t l Om U*) :precision binary64 (if (or (<= l -8800.0) (not (<= l 1.75e+49))) (sqrt (* 2.0 (/ (* -2.0 (* n (* l (* U l)))) Om))) (pow (* 2.0 (* n (* U t))) 0.5)))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((l <= -8800.0) || !(l <= 1.75e+49)) {
tmp = sqrt((2.0 * ((-2.0 * (n * (l * (U * l)))) / Om)));
} else {
tmp = pow((2.0 * (n * (U * t))), 0.5);
}
return tmp;
}
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 <= (-8800.0d0)) .or. (.not. (l <= 1.75d+49))) then
tmp = sqrt((2.0d0 * (((-2.0d0) * (n * (l * (u * l)))) / om)))
else
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((l <= -8800.0) || !(l <= 1.75e+49)) {
tmp = Math.sqrt((2.0 * ((-2.0 * (n * (l * (U * l)))) / Om)));
} else {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if (l <= -8800.0) or not (l <= 1.75e+49): tmp = math.sqrt((2.0 * ((-2.0 * (n * (l * (U * l)))) / Om))) else: tmp = math.pow((2.0 * (n * (U * t))), 0.5) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((l <= -8800.0) || !(l <= 1.75e+49)) tmp = sqrt(Float64(2.0 * Float64(Float64(-2.0 * Float64(n * Float64(l * Float64(U * l)))) / Om))); else tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if ((l <= -8800.0) || ~((l <= 1.75e+49))) tmp = sqrt((2.0 * ((-2.0 * (n * (l * (U * l)))) / Om))); else tmp = (2.0 * (n * (U * t))) ^ 0.5; end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[Or[LessEqual[l, -8800.0], N[Not[LessEqual[l, 1.75e+49]], $MachinePrecision]], N[Sqrt[N[(2.0 * N[(N[(-2.0 * N[(n * N[(l * N[(U * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -8800 \lor \neg \left(\ell \leq 1.75 \cdot 10^{+49}\right):\\
\;\;\;\;\sqrt{2 \cdot \frac{-2 \cdot \left(n \cdot \left(\ell \cdot \left(U \cdot \ell\right)\right)\right)}{Om}}\\
\mathbf{else}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\end{array}
\end{array}
if l < -8800 or 1.74999999999999987e49 < l Initial program 35.6%
associate-*l*33.8%
sub-neg33.8%
associate--l+33.8%
*-commutative33.8%
distribute-rgt-neg-in33.8%
associate-*l/42.8%
associate-*l*42.8%
*-commutative42.8%
*-commutative42.8%
associate-*l*42.4%
unpow242.4%
associate-*l*43.6%
Simplified51.1%
Taylor expanded in l around inf 36.1%
associate-*r*34.0%
unpow234.0%
associate-/l*34.3%
unpow234.3%
associate-*r/34.3%
metadata-eval34.3%
Simplified34.3%
Taylor expanded in n around 0 25.5%
associate-*r/25.5%
*-commutative25.5%
unpow225.5%
associate-*l*29.5%
*-commutative29.5%
*-commutative29.5%
Simplified29.5%
if -8800 < l < 1.74999999999999987e49Initial program 62.5%
associate-*l*63.2%
sub-neg63.2%
associate--l+63.2%
*-commutative63.2%
distribute-rgt-neg-in63.2%
associate-*l/63.2%
associate-*l*63.2%
*-commutative63.2%
*-commutative63.2%
associate-*l*56.8%
unpow256.8%
associate-*l*58.2%
Simplified58.9%
Taylor expanded in t around inf 51.2%
pow1/251.9%
associate-*l*51.9%
*-commutative51.9%
Applied egg-rr51.9%
Final simplification43.4%
(FPCore (n U t l Om U*) :precision binary64 (if (<= t -1.25e+162) (pow (* 2.0 (* n (* U t))) 0.5) (sqrt (* 2.0 (* (* n U) (+ t (* -2.0 (/ (* l l) Om))))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (t <= -1.25e+162) {
tmp = pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
}
return tmp;
}
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 (t <= (-1.25d+162)) then
tmp = (2.0d0 * (n * (u * t))) ** 0.5d0
else
tmp = sqrt((2.0d0 * ((n * u) * (t + ((-2.0d0) * ((l * l) / om))))))
end if
code = tmp
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (t <= -1.25e+162) {
tmp = Math.pow((2.0 * (n * (U * t))), 0.5);
} else {
tmp = Math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om))))));
}
return tmp;
}
def code(n, U, t, l, Om, U_42_): tmp = 0 if t <= -1.25e+162: tmp = math.pow((2.0 * (n * (U * t))), 0.5) else: tmp = math.sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))) return tmp
function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (t <= -1.25e+162) tmp = Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5; else tmp = sqrt(Float64(2.0 * Float64(Float64(n * U) * Float64(t + Float64(-2.0 * Float64(Float64(l * l) / Om)))))); end return tmp end
function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (t <= -1.25e+162) tmp = (2.0 * (n * (U * t))) ^ 0.5; else tmp = sqrt((2.0 * ((n * U) * (t + (-2.0 * ((l * l) / Om)))))); end tmp_2 = tmp; end
code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[t, -1.25e+162], N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(2.0 * N[(N[(n * U), $MachinePrecision] * N[(t + N[(-2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.25 \cdot 10^{+162}:\\
\;\;\;\;{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(n \cdot U\right) \cdot \left(t + -2 \cdot \frac{\ell \cdot \ell}{Om}\right)\right)}\\
\end{array}
\end{array}
if t < -1.2499999999999999e162Initial program 44.4%
associate-*l*51.8%
sub-neg51.8%
associate--l+51.8%
*-commutative51.8%
distribute-rgt-neg-in51.8%
associate-*l/61.0%
associate-*l*61.0%
*-commutative61.0%
*-commutative61.0%
associate-*l*57.2%
unpow257.2%
associate-*l*60.6%
Simplified67.0%
Taylor expanded in t around inf 61.0%
pow1/264.3%
associate-*l*64.3%
*-commutative64.3%
Applied egg-rr64.3%
if -1.2499999999999999e162 < t Initial program 53.3%
associate-*l*52.0%
sub-neg52.0%
associate--l+52.0%
*-commutative52.0%
distribute-rgt-neg-in52.0%
associate-*l/54.6%
associate-*l*54.6%
*-commutative54.6%
*-commutative54.6%
associate-*l*50.5%
unpow250.5%
associate-*l*51.5%
Simplified54.3%
*-un-lft-identity54.3%
associate-*l*54.3%
Applied egg-rr54.3%
*-lft-identity54.3%
associate-*r*56.9%
*-commutative56.9%
associate-*r*60.2%
Simplified60.2%
Taylor expanded in n around 0 43.7%
unpow243.7%
Simplified43.7%
Final simplification46.3%
(FPCore (n U t l Om U*) :precision binary64 (pow (* 2.0 (* n (* U t))) 0.5))
double code(double n, double U, double t, double l, double Om, double U_42_) {
return pow((2.0 * (n * (U * t))), 0.5);
}
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 = (2.0d0 * (n * (u * t))) ** 0.5d0
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.pow((2.0 * (n * (U * t))), 0.5);
}
def code(n, U, t, l, Om, U_42_): return math.pow((2.0 * (n * (U * t))), 0.5)
function code(n, U, t, l, Om, U_42_) return Float64(2.0 * Float64(n * Float64(U * t))) ^ 0.5 end
function tmp = code(n, U, t, l, Om, U_42_) tmp = (2.0 * (n * (U * t))) ^ 0.5; end
code[n_, U_, t_, l_, Om_, U$42$_] := N[Power[N[(2.0 * N[(n * N[(U * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]
\begin{array}{l}
\\
{\left(2 \cdot \left(n \cdot \left(U \cdot t\right)\right)\right)}^{0.5}
\end{array}
Initial program 52.2%
associate-*l*51.9%
sub-neg51.9%
associate--l+51.9%
*-commutative51.9%
distribute-rgt-neg-in51.9%
associate-*l/55.4%
associate-*l*55.4%
*-commutative55.4%
*-commutative55.4%
associate-*l*51.3%
unpow251.3%
associate-*l*52.6%
Simplified55.9%
Taylor expanded in t around inf 37.3%
pow1/238.2%
associate-*l*38.2%
*-commutative38.2%
Applied egg-rr38.2%
Final simplification38.2%
(FPCore (n U t l Om U*) :precision binary64 (sqrt (* (* n 2.0) (* U t))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt(((n * 2.0) * (U * t)));
}
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(((n * 2.0d0) * (u * t)))
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt(((n * 2.0) * (U * t)));
}
def code(n, U, t, l, Om, U_42_): return math.sqrt(((n * 2.0) * (U * t)))
function code(n, U, t, l, Om, U_42_) return sqrt(Float64(Float64(n * 2.0) * Float64(U * t))) end
function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt(((n * 2.0) * (U * t))); end
code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(N[(n * 2.0), $MachinePrecision] * N[(U * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left(n \cdot 2\right) \cdot \left(U \cdot t\right)}
\end{array}
Initial program 52.2%
associate-*l*51.9%
sub-neg51.9%
associate--l+51.9%
*-commutative51.9%
distribute-rgt-neg-in51.9%
associate-*l/55.4%
associate-*l*55.4%
*-commutative55.4%
*-commutative55.4%
associate-*l*51.3%
unpow251.3%
associate-*l*52.6%
Simplified55.9%
Taylor expanded in t around inf 37.3%
Final simplification37.3%
herbie shell --seed 2023178
(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*))))))