
(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}
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (/ l Om)))
(t_2 (* (* n (pow (/ l Om) 2.0)) (- U* U)))
(t_3 (* U (* 2.0 n)))
(t_4 (sqrt (* t_3 (+ (- t (* 2.0 (/ (* l l) Om))) t_2)))))
(if (<= t_4 0.0)
(sqrt (* 2.0 (* U (* n (fma t_1 -2.0 t)))))
(if (<= t_4 INFINITY)
(sqrt (* t_3 (+ (- t (* 2.0 t_1)) t_2)))
(*
(* l (sqrt 2.0))
(sqrt (* U (* (/ n Om) (+ -2.0 (* (/ n Om) (- U* U)))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double t_2 = (n * pow((l / Om), 2.0)) * (U_42_ - U);
double t_3 = U * (2.0 * n);
double t_4 = sqrt((t_3 * ((t - (2.0 * ((l * l) / Om))) + t_2)));
double tmp;
if (t_4 <= 0.0) {
tmp = sqrt((2.0 * (U * (n * fma(t_1, -2.0, t)))));
} else if (t_4 <= ((double) INFINITY)) {
tmp = sqrt((t_3 * ((t - (2.0 * t_1)) + t_2)));
} else {
tmp = (l * sqrt(2.0)) * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * Float64(l / Om)) t_2 = Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U_42_ - U)) t_3 = Float64(U * Float64(2.0 * n)) t_4 = sqrt(Float64(t_3 * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) + t_2))) tmp = 0.0 if (t_4 <= 0.0) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(t_1, -2.0, t))))); elseif (t_4 <= Inf) tmp = sqrt(Float64(t_3 * Float64(Float64(t - Float64(2.0 * t_1)) + t_2))); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(U * Float64(Float64(n / Om) * Float64(-2.0 + Float64(Float64(n / Om) * Float64(U_42_ - U))))))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[Sqrt[N[(t$95$3 * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$4, 0.0], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t$95$1 * -2.0 + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[Sqrt[N[(t$95$3 * N[(N[(t - N[(2.0 * t$95$1), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(U * N[(N[(n / Om), $MachinePrecision] * N[(-2.0 + N[(N[(n / Om), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \frac{\ell}{Om}\\
t_2 := \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U* - U\right)\\
t_3 := U \cdot \left(2 \cdot n\right)\\
t_4 := \sqrt{t_3 \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) + t_2\right)}\\
\mathbf{if}\;t_4 \leq 0:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(t_1, -2, t\right)\right)\right)}\\
\mathbf{elif}\;t_4 \leq \infty:\\
\;\;\;\;\sqrt{t_3 \cdot \left(\left(t - 2 \cdot t_1\right) + t_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{U \cdot \left(\frac{n}{Om} \cdot \left(-2 + \frac{n}{Om} \cdot \left(U* - U\right)\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 9.4%
associate-*l/9.4%
Applied egg-rr9.4%
Taylor expanded in n around 0 40.0%
cancel-sign-sub-inv40.0%
metadata-eval40.0%
+-commutative40.0%
*-commutative40.0%
unpow240.0%
associate-*r/40.0%
fma-udef40.0%
Simplified40.0%
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 65.0%
associate-*l/70.9%
Applied egg-rr70.9%
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%
Simplified10.1%
Taylor expanded in l around inf 28.8%
unpow228.8%
sub-neg28.8%
unpow228.8%
times-frac37.0%
associate-*r/37.0%
metadata-eval37.0%
distribute-neg-frac37.0%
metadata-eval37.0%
Simplified37.0%
Taylor expanded in l around 0 29.3%
*-commutative29.3%
sub-neg29.3%
unpow229.3%
times-frac36.8%
distribute-rgt-in31.2%
associate-*r/31.2%
metadata-eval31.2%
distribute-neg-frac31.2%
metadata-eval31.2%
Simplified40.3%
Final simplification61.5%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (sqrt 2.0)))
(t_2 (/ (* l l) Om))
(t_3
(sqrt
(*
(* 2.0 (* n U))
(+ (+ t (* t_2 -2.0)) (* n (* (pow (/ l Om) 2.0) (- U* U))))))))
(if (<= l 1.18e-18)
t_3
(if (<= l 8.5e+24)
(sqrt
(*
2.0
(* U (* n (+ (fma t_2 -2.0 t) (/ U* (/ (* Om Om) (* n (* l l)))))))))
(if (<= l 4.4e+50)
t_3
(if (<= l 1.32e+132)
(sqrt
(+ (* -4.0 (/ (* U (* n (pow l 2.0))) Om)) (* 2.0 (* U (* n t)))))
(if (<= l 3.8e+192)
(* t_1 (sqrt (* U (* (/ n Om) (+ -2.0 (* (/ n Om) (- U* U)))))))
(if (<= l 2.5e+243)
(sqrt
(*
2.0
(*
(* U l)
(* (* n l) (fma (/ n Om) (/ (- U* U) Om) (/ -2.0 Om))))))
(*
t_1
(sqrt
(/ (* U (* n (- (/ (* n (- U* U)) Om) 2.0))) Om)))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * sqrt(2.0);
double t_2 = (l * l) / Om;
double t_3 = sqrt(((2.0 * (n * U)) * ((t + (t_2 * -2.0)) + (n * (pow((l / Om), 2.0) * (U_42_ - U))))));
double tmp;
if (l <= 1.18e-18) {
tmp = t_3;
} else if (l <= 8.5e+24) {
tmp = sqrt((2.0 * (U * (n * (fma(t_2, -2.0, t) + (U_42_ / ((Om * Om) / (n * (l * l)))))))));
} else if (l <= 4.4e+50) {
tmp = t_3;
} else if (l <= 1.32e+132) {
tmp = sqrt(((-4.0 * ((U * (n * pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 3.8e+192) {
tmp = t_1 * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))));
} else if (l <= 2.5e+243) {
tmp = sqrt((2.0 * ((U * l) * ((n * l) * fma((n / Om), ((U_42_ - U) / Om), (-2.0 / Om))))));
} else {
tmp = t_1 * sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * sqrt(2.0)) t_2 = Float64(Float64(l * l) / Om) t_3 = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(Float64(t + Float64(t_2 * -2.0)) + Float64(n * Float64((Float64(l / Om) ^ 2.0) * Float64(U_42_ - U)))))) tmp = 0.0 if (l <= 1.18e-18) tmp = t_3; elseif (l <= 8.5e+24) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(fma(t_2, -2.0, t) + Float64(U_42_ / Float64(Float64(Om * Om) / Float64(n * Float64(l * l))))))))); elseif (l <= 4.4e+50) tmp = t_3; elseif (l <= 1.32e+132) tmp = sqrt(Float64(Float64(-4.0 * Float64(Float64(U * Float64(n * (l ^ 2.0))) / Om)) + Float64(2.0 * Float64(U * Float64(n * t))))); elseif (l <= 3.8e+192) tmp = Float64(t_1 * sqrt(Float64(U * Float64(Float64(n / Om) * Float64(-2.0 + Float64(Float64(n / Om) * Float64(U_42_ - U))))))); elseif (l <= 2.5e+243) tmp = sqrt(Float64(2.0 * Float64(Float64(U * l) * Float64(Float64(n * l) * fma(Float64(n / Om), Float64(Float64(U_42_ - U) / Om), Float64(-2.0 / Om)))))); else tmp = Float64(t_1 * sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 2.0))) / Om))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(N[(t + N[(t$95$2 * -2.0), $MachinePrecision]), $MachinePrecision] + N[(n * N[(N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, 1.18e-18], t$95$3, If[LessEqual[l, 8.5e+24], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(t$95$2 * -2.0 + t), $MachinePrecision] + N[(U$42$ / N[(N[(Om * Om), $MachinePrecision] / N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 4.4e+50], t$95$3, If[LessEqual[l, 1.32e+132], N[Sqrt[N[(N[(-4.0 * N[(N[(U * N[(n * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.8e+192], N[(t$95$1 * N[Sqrt[N[(U * N[(N[(n / Om), $MachinePrecision] * N[(-2.0 + N[(N[(n / Om), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 2.5e+243], N[Sqrt[N[(2.0 * N[(N[(U * l), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(t$95$1 * N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \sqrt{2}\\
t_2 := \frac{\ell \cdot \ell}{Om}\\
t_3 := \sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(\left(t + t_2 \cdot -2\right) + n \cdot \left({\left(\frac{\ell}{Om}\right)}^{2} \cdot \left(U* - U\right)\right)\right)}\\
\mathbf{if}\;\ell \leq 1.18 \cdot 10^{-18}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;\ell \leq 8.5 \cdot 10^{+24}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(\mathsf{fma}\left(t_2, -2, t\right) + \frac{U*}{\frac{Om \cdot Om}{n \cdot \left(\ell \cdot \ell\right)}}\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 4.4 \cdot 10^{+50}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;\ell \leq 1.32 \cdot 10^{+132}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot {\ell}^{2}\right)}{Om} + 2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.8 \cdot 10^{+192}:\\
\;\;\;\;t_1 \cdot \sqrt{U \cdot \left(\frac{n}{Om} \cdot \left(-2 + \frac{n}{Om} \cdot \left(U* - U\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.5 \cdot 10^{+243}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(U \cdot \ell\right) \cdot \left(\left(n \cdot \ell\right) \cdot \mathsf{fma}\left(\frac{n}{Om}, \frac{U* - U}{Om}, \frac{-2}{Om}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 1.18000000000000008e-18 or 8.49999999999999959e24 < l < 4.40000000000000034e50Initial program 50.7%
Simplified50.7%
if 1.18000000000000008e-18 < l < 8.49999999999999959e24Initial program 53.5%
Simplified46.9%
Taylor expanded in U around 0 67.5%
remove-double-neg67.5%
mul-1-neg67.5%
sub-neg67.5%
associate--l+67.5%
sub-neg67.5%
Simplified78.6%
if 4.40000000000000034e50 < l < 1.3199999999999999e132Initial program 50.7%
Simplified50.3%
Taylor expanded in Om around inf 61.8%
if 1.3199999999999999e132 < l < 3.7999999999999999e192Initial program 29.8%
Simplified40.1%
Taylor expanded in l around inf 31.9%
unpow231.9%
sub-neg31.9%
unpow231.9%
times-frac32.3%
associate-*r/32.3%
metadata-eval32.3%
distribute-neg-frac32.3%
metadata-eval32.3%
Simplified32.3%
Taylor expanded in l around 0 42.0%
*-commutative42.0%
sub-neg42.0%
unpow242.0%
times-frac51.7%
distribute-rgt-in51.7%
associate-*r/51.7%
metadata-eval51.7%
distribute-neg-frac51.7%
metadata-eval51.7%
Simplified70.1%
if 3.7999999999999999e192 < l < 2.50000000000000019e243Initial program 22.1%
Simplified43.8%
Taylor expanded in l around inf 36.8%
unpow236.8%
sub-neg36.8%
unpow236.8%
times-frac37.3%
associate-*r/37.3%
metadata-eval37.3%
distribute-neg-frac37.3%
metadata-eval37.3%
Simplified37.3%
*-un-lft-identity37.3%
associate-*l*58.9%
fma-def58.9%
Applied egg-rr58.9%
*-lft-identity58.9%
associate-*r*65.8%
associate-*r*92.4%
Simplified92.4%
if 2.50000000000000019e243 < l Initial program 14.0%
Simplified14.3%
Taylor expanded in l around inf 28.4%
unpow228.4%
sub-neg28.4%
unpow228.4%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.4%
unpow228.4%
unpow228.4%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*34.7%
fma-udef34.7%
distribute-rgt-out34.7%
Simplified34.7%
Taylor expanded in l around 0 72.5%
Final simplification56.8%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (sqrt 2.0))))
(if (<= l 1.5e+29)
(sqrt
(*
2.0
(*
U
(*
n
(+ (fma (/ (* l l) Om) -2.0 t) (/ U* (/ (* Om Om) (* n (* l l)))))))))
(if (<= l 9e+130)
(sqrt (+ (* -4.0 (/ (* U (* n (pow l 2.0))) Om)) (* 2.0 (* U (* n t)))))
(if (<= l 3.3e+193)
(* t_1 (sqrt (* U (* (/ n Om) (+ -2.0 (* (/ n Om) (- U* U)))))))
(if (<= l 1.46e+245)
(sqrt
(*
2.0
(*
(* U l)
(* (* n l) (fma (/ n Om) (/ (- U* U) Om) (/ -2.0 Om))))))
(*
t_1
(sqrt (/ (* U (* n (- (/ (* n (- U* U)) Om) 2.0))) Om)))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * sqrt(2.0);
double tmp;
if (l <= 1.5e+29) {
tmp = sqrt((2.0 * (U * (n * (fma(((l * l) / Om), -2.0, t) + (U_42_ / ((Om * Om) / (n * (l * l)))))))));
} else if (l <= 9e+130) {
tmp = sqrt(((-4.0 * ((U * (n * pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 3.3e+193) {
tmp = t_1 * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))));
} else if (l <= 1.46e+245) {
tmp = sqrt((2.0 * ((U * l) * ((n * l) * fma((n / Om), ((U_42_ - U) / Om), (-2.0 / Om))))));
} else {
tmp = t_1 * sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * sqrt(2.0)) tmp = 0.0 if (l <= 1.5e+29) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * Float64(fma(Float64(Float64(l * l) / Om), -2.0, t) + Float64(U_42_ / Float64(Float64(Om * Om) / Float64(n * Float64(l * l))))))))); elseif (l <= 9e+130) tmp = sqrt(Float64(Float64(-4.0 * Float64(Float64(U * Float64(n * (l ^ 2.0))) / Om)) + Float64(2.0 * Float64(U * Float64(n * t))))); elseif (l <= 3.3e+193) tmp = Float64(t_1 * sqrt(Float64(U * Float64(Float64(n / Om) * Float64(-2.0 + Float64(Float64(n / Om) * Float64(U_42_ - U))))))); elseif (l <= 1.46e+245) tmp = sqrt(Float64(2.0 * Float64(Float64(U * l) * Float64(Float64(n * l) * fma(Float64(n / Om), Float64(Float64(U_42_ - U) / Om), Float64(-2.0 / Om)))))); else tmp = Float64(t_1 * sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 2.0))) / Om))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 1.5e+29], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision] * -2.0 + t), $MachinePrecision] + N[(U$42$ / N[(N[(Om * Om), $MachinePrecision] / N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 9e+130], N[Sqrt[N[(N[(-4.0 * N[(N[(U * N[(n * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.3e+193], N[(t$95$1 * N[Sqrt[N[(U * N[(N[(n / Om), $MachinePrecision] * N[(-2.0 + N[(N[(n / Om), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 1.46e+245], N[Sqrt[N[(2.0 * N[(N[(U * l), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(t$95$1 * N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \sqrt{2}\\
\mathbf{if}\;\ell \leq 1.5 \cdot 10^{+29}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \left(\mathsf{fma}\left(\frac{\ell \cdot \ell}{Om}, -2, t\right) + \frac{U*}{\frac{Om \cdot Om}{n \cdot \left(\ell \cdot \ell\right)}}\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 9 \cdot 10^{+130}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot {\ell}^{2}\right)}{Om} + 2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.3 \cdot 10^{+193}:\\
\;\;\;\;t_1 \cdot \sqrt{U \cdot \left(\frac{n}{Om} \cdot \left(-2 + \frac{n}{Om} \cdot \left(U* - U\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 1.46 \cdot 10^{+245}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(U \cdot \ell\right) \cdot \left(\left(n \cdot \ell\right) \cdot \mathsf{fma}\left(\frac{n}{Om}, \frac{U* - U}{Om}, \frac{-2}{Om}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 1.5e29Initial program 51.0%
Simplified55.2%
Taylor expanded in U around 0 45.8%
remove-double-neg45.8%
mul-1-neg45.8%
sub-neg45.8%
associate--l+45.8%
sub-neg45.8%
Simplified47.4%
if 1.5e29 < l < 9.00000000000000078e130Initial program 49.3%
Simplified52.9%
Taylor expanded in Om around inf 53.8%
if 9.00000000000000078e130 < l < 3.3e193Initial program 29.8%
Simplified40.1%
Taylor expanded in l around inf 31.9%
unpow231.9%
sub-neg31.9%
unpow231.9%
times-frac32.3%
associate-*r/32.3%
metadata-eval32.3%
distribute-neg-frac32.3%
metadata-eval32.3%
Simplified32.3%
Taylor expanded in l around 0 42.0%
*-commutative42.0%
sub-neg42.0%
unpow242.0%
times-frac51.7%
distribute-rgt-in51.7%
associate-*r/51.7%
metadata-eval51.7%
distribute-neg-frac51.7%
metadata-eval51.7%
Simplified70.1%
if 3.3e193 < l < 1.45999999999999991e245Initial program 22.1%
Simplified43.8%
Taylor expanded in l around inf 36.8%
unpow236.8%
sub-neg36.8%
unpow236.8%
times-frac37.3%
associate-*r/37.3%
metadata-eval37.3%
distribute-neg-frac37.3%
metadata-eval37.3%
Simplified37.3%
*-un-lft-identity37.3%
associate-*l*58.9%
fma-def58.9%
Applied egg-rr58.9%
*-lft-identity58.9%
associate-*r*65.8%
associate-*r*92.4%
Simplified92.4%
if 1.45999999999999991e245 < l Initial program 14.0%
Simplified14.3%
Taylor expanded in l around inf 28.4%
unpow228.4%
sub-neg28.4%
unpow228.4%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.4%
unpow228.4%
unpow228.4%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*34.7%
fma-udef34.7%
distribute-rgt-out34.7%
Simplified34.7%
Taylor expanded in l around 0 72.5%
Final simplification53.0%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (sqrt 2.0))))
(if (<= l 9e+129)
(sqrt (+ (* -4.0 (/ (* U (* n (pow l 2.0))) Om)) (* 2.0 (* U (* n t)))))
(if (<= l 3e+193)
(* t_1 (sqrt (* U (* (/ n Om) (+ -2.0 (* (/ n Om) (- U* U)))))))
(if (<= l 8.8e+243)
(sqrt
(*
2.0
(* (* U l) (* (* n l) (fma (/ n Om) (/ (- U* U) Om) (/ -2.0 Om))))))
(* t_1 (sqrt (/ (* U (* n (- (/ (* n (- U* U)) Om) 2.0))) Om))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * sqrt(2.0);
double tmp;
if (l <= 9e+129) {
tmp = sqrt(((-4.0 * ((U * (n * pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 3e+193) {
tmp = t_1 * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))));
} else if (l <= 8.8e+243) {
tmp = sqrt((2.0 * ((U * l) * ((n * l) * fma((n / Om), ((U_42_ - U) / Om), (-2.0 / Om))))));
} else {
tmp = t_1 * sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * sqrt(2.0)) tmp = 0.0 if (l <= 9e+129) tmp = sqrt(Float64(Float64(-4.0 * Float64(Float64(U * Float64(n * (l ^ 2.0))) / Om)) + Float64(2.0 * Float64(U * Float64(n * t))))); elseif (l <= 3e+193) tmp = Float64(t_1 * sqrt(Float64(U * Float64(Float64(n / Om) * Float64(-2.0 + Float64(Float64(n / Om) * Float64(U_42_ - U))))))); elseif (l <= 8.8e+243) tmp = sqrt(Float64(2.0 * Float64(Float64(U * l) * Float64(Float64(n * l) * fma(Float64(n / Om), Float64(Float64(U_42_ - U) / Om), Float64(-2.0 / Om)))))); else tmp = Float64(t_1 * sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 2.0))) / Om))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 9e+129], N[Sqrt[N[(N[(-4.0 * N[(N[(U * N[(n * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3e+193], N[(t$95$1 * N[Sqrt[N[(U * N[(N[(n / Om), $MachinePrecision] * N[(-2.0 + N[(N[(n / Om), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 8.8e+243], N[Sqrt[N[(2.0 * N[(N[(U * l), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(t$95$1 * N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \sqrt{2}\\
\mathbf{if}\;\ell \leq 9 \cdot 10^{+129}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot {\ell}^{2}\right)}{Om} + 2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 3 \cdot 10^{+193}:\\
\;\;\;\;t_1 \cdot \sqrt{U \cdot \left(\frac{n}{Om} \cdot \left(-2 + \frac{n}{Om} \cdot \left(U* - U\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 8.8 \cdot 10^{+243}:\\
\;\;\;\;\sqrt{2 \cdot \left(\left(U \cdot \ell\right) \cdot \left(\left(n \cdot \ell\right) \cdot \mathsf{fma}\left(\frac{n}{Om}, \frac{U* - U}{Om}, \frac{-2}{Om}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 9.0000000000000003e129Initial program 50.8%
Simplified51.0%
Taylor expanded in Om around inf 45.5%
if 9.0000000000000003e129 < l < 3e193Initial program 29.8%
Simplified40.1%
Taylor expanded in l around inf 31.9%
unpow231.9%
sub-neg31.9%
unpow231.9%
times-frac32.3%
associate-*r/32.3%
metadata-eval32.3%
distribute-neg-frac32.3%
metadata-eval32.3%
Simplified32.3%
Taylor expanded in l around 0 42.0%
*-commutative42.0%
sub-neg42.0%
unpow242.0%
times-frac51.7%
distribute-rgt-in51.7%
associate-*r/51.7%
metadata-eval51.7%
distribute-neg-frac51.7%
metadata-eval51.7%
Simplified70.1%
if 3e193 < l < 8.80000000000000035e243Initial program 22.1%
Simplified43.8%
Taylor expanded in l around inf 36.8%
unpow236.8%
sub-neg36.8%
unpow236.8%
times-frac37.3%
associate-*r/37.3%
metadata-eval37.3%
distribute-neg-frac37.3%
metadata-eval37.3%
Simplified37.3%
*-un-lft-identity37.3%
associate-*l*58.9%
fma-def58.9%
Applied egg-rr58.9%
*-lft-identity58.9%
associate-*r*65.8%
associate-*r*92.4%
Simplified92.4%
if 8.80000000000000035e243 < l Initial program 14.0%
Simplified14.3%
Taylor expanded in l around inf 28.4%
unpow228.4%
sub-neg28.4%
unpow228.4%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.4%
unpow228.4%
unpow228.4%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*34.7%
fma-udef34.7%
distribute-rgt-out34.7%
Simplified34.7%
Taylor expanded in l around 0 72.5%
Final simplification50.7%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 3.5e+133)
(sqrt (+ (* -4.0 (/ (* U (* n (pow l 2.0))) Om)) (* 2.0 (* U (* n t)))))
(if (<= l 2.85e+206)
(*
(sqrt 2.0)
(* l (sqrt (* U (* (/ n Om) (+ -2.0 (* (/ n Om) (- U* U))))))))
(if (<= l 3.6e+244)
(sqrt (* 2.0 (* U (* l (/ (* l (* n (- (/ (* n U*) Om) 2.0))) Om)))))
(*
(* l (sqrt 2.0))
(sqrt (/ (* U (* n (- (/ (* n (- U* U)) Om) 2.0))) Om)))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 3.5e+133) {
tmp = sqrt(((-4.0 * ((U * (n * pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 2.85e+206) {
tmp = sqrt(2.0) * (l * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U)))))));
} else if (l <= 3.6e+244) {
tmp = sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om)))));
} else {
tmp = (l * sqrt(2.0)) * sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 3.5d+133) then
tmp = sqrt((((-4.0d0) * ((u * (n * (l ** 2.0d0))) / om)) + (2.0d0 * (u * (n * t)))))
else if (l <= 2.85d+206) then
tmp = sqrt(2.0d0) * (l * sqrt((u * ((n / om) * ((-2.0d0) + ((n / om) * (u_42 - u)))))))
else if (l <= 3.6d+244) then
tmp = sqrt((2.0d0 * (u * (l * ((l * (n * (((n * u_42) / om) - 2.0d0))) / om)))))
else
tmp = (l * sqrt(2.0d0)) * sqrt(((u * (n * (((n * (u_42 - u)) / om) - 2.0d0))) / om))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 3.5e+133) {
tmp = Math.sqrt(((-4.0 * ((U * (n * Math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 2.85e+206) {
tmp = Math.sqrt(2.0) * (l * Math.sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U)))))));
} else if (l <= 3.6e+244) {
tmp = Math.sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om)))));
} else {
tmp = (l * Math.sqrt(2.0)) * Math.sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 3.5e+133: tmp = math.sqrt(((-4.0 * ((U * (n * math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t))))) elif l <= 2.85e+206: tmp = math.sqrt(2.0) * (l * math.sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))))) elif l <= 3.6e+244: tmp = math.sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om))))) else: tmp = (l * math.sqrt(2.0)) * math.sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 3.5e+133) tmp = sqrt(Float64(Float64(-4.0 * Float64(Float64(U * Float64(n * (l ^ 2.0))) / Om)) + Float64(2.0 * Float64(U * Float64(n * t))))); elseif (l <= 2.85e+206) tmp = Float64(sqrt(2.0) * Float64(l * sqrt(Float64(U * Float64(Float64(n / Om) * Float64(-2.0 + Float64(Float64(n / Om) * Float64(U_42_ - U)))))))); elseif (l <= 3.6e+244) tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(l * Float64(n * Float64(Float64(Float64(n * U_42_) / Om) - 2.0))) / Om))))); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 2.0))) / Om))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 3.5e+133) tmp = sqrt(((-4.0 * ((U * (n * (l ^ 2.0))) / Om)) + (2.0 * (U * (n * t))))); elseif (l <= 2.85e+206) tmp = sqrt(2.0) * (l * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))))); elseif (l <= 3.6e+244) tmp = sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om))))); else tmp = (l * sqrt(2.0)) * sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 3.5e+133], N[Sqrt[N[(N[(-4.0 * N[(N[(U * N[(n * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 2.85e+206], N[(N[Sqrt[2.0], $MachinePrecision] * N[(l * N[Sqrt[N[(U * N[(N[(n / Om), $MachinePrecision] * N[(-2.0 + N[(N[(n / Om), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 3.6e+244], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(l * N[(n * N[(N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 3.5 \cdot 10^{+133}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot {\ell}^{2}\right)}{Om} + 2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.85 \cdot 10^{+206}:\\
\;\;\;\;\sqrt{2} \cdot \left(\ell \cdot \sqrt{U \cdot \left(\frac{n}{Om} \cdot \left(-2 + \frac{n}{Om} \cdot \left(U* - U\right)\right)\right)}\right)\\
\mathbf{elif}\;\ell \leq 3.6 \cdot 10^{+244}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \frac{\ell \cdot \left(n \cdot \left(\frac{n \cdot U*}{Om} - 2\right)\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 3.4999999999999998e133Initial program 50.8%
Simplified51.0%
Taylor expanded in Om around inf 45.5%
if 3.4999999999999998e133 < l < 2.8499999999999999e206Initial program 29.0%
Simplified50.4%
sqrt-prod50.4%
Applied egg-rr50.4%
Taylor expanded in l around inf 44.5%
*-commutative44.5%
sub-neg44.5%
unpow244.5%
times-frac58.5%
distribute-rgt-in58.5%
associate-*r/58.5%
metadata-eval58.5%
distribute-neg-frac58.5%
metadata-eval58.5%
Simplified71.6%
if 2.8499999999999999e206 < l < 3.6e244Initial program 20.3%
Simplified30.8%
Taylor expanded in l around inf 41.0%
unpow241.0%
sub-neg41.0%
unpow241.0%
times-frac41.0%
associate-*r/41.0%
metadata-eval41.0%
distribute-neg-frac41.0%
metadata-eval41.0%
Simplified41.0%
Taylor expanded in l around 0 41.0%
unpow241.0%
unpow241.0%
times-frac41.0%
fma-neg41.0%
associate-*r/41.0%
metadata-eval41.0%
distribute-neg-frac41.0%
metadata-eval41.0%
associate-*r*61.4%
fma-udef61.4%
distribute-rgt-out41.4%
Simplified61.4%
Taylor expanded in U around 0 90.3%
if 3.6e244 < l Initial program 14.0%
Simplified14.3%
Taylor expanded in l around inf 28.4%
unpow228.4%
sub-neg28.4%
unpow228.4%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.4%
unpow228.4%
unpow228.4%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*34.7%
fma-udef34.7%
distribute-rgt-out34.7%
Simplified34.7%
Taylor expanded in l around 0 72.5%
Final simplification50.4%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (sqrt 2.0))))
(if (<= l 1.05e+130)
(sqrt (+ (* -4.0 (/ (* U (* n (pow l 2.0))) Om)) (* 2.0 (* U (* n t)))))
(if (<= l 2.45e+207)
(* t_1 (sqrt (* U (* (/ n Om) (+ -2.0 (* (/ n Om) (- U* U)))))))
(if (<= l 2.5e+244)
(sqrt (* 2.0 (* U (* l (/ (* l (* n (- (/ (* n U*) Om) 2.0))) Om)))))
(* t_1 (sqrt (/ (* U (* n (- (/ (* n (- U* U)) Om) 2.0))) Om))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * sqrt(2.0);
double tmp;
if (l <= 1.05e+130) {
tmp = sqrt(((-4.0 * ((U * (n * pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 2.45e+207) {
tmp = t_1 * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))));
} else if (l <= 2.5e+244) {
tmp = sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om)))));
} else {
tmp = t_1 * sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: t_1
real(8) :: tmp
t_1 = l * sqrt(2.0d0)
if (l <= 1.05d+130) then
tmp = sqrt((((-4.0d0) * ((u * (n * (l ** 2.0d0))) / om)) + (2.0d0 * (u * (n * t)))))
else if (l <= 2.45d+207) then
tmp = t_1 * sqrt((u * ((n / om) * ((-2.0d0) + ((n / om) * (u_42 - u))))))
else if (l <= 2.5d+244) then
tmp = sqrt((2.0d0 * (u * (l * ((l * (n * (((n * u_42) / om) - 2.0d0))) / om)))))
else
tmp = t_1 * sqrt(((u * (n * (((n * (u_42 - u)) / om) - 2.0d0))) / om))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * Math.sqrt(2.0);
double tmp;
if (l <= 1.05e+130) {
tmp = Math.sqrt(((-4.0 * ((U * (n * Math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 2.45e+207) {
tmp = t_1 * Math.sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))));
} else if (l <= 2.5e+244) {
tmp = Math.sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om)))));
} else {
tmp = t_1 * Math.sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = l * math.sqrt(2.0) tmp = 0 if l <= 1.05e+130: tmp = math.sqrt(((-4.0 * ((U * (n * math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t))))) elif l <= 2.45e+207: tmp = t_1 * math.sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U)))))) elif l <= 2.5e+244: tmp = math.sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om))))) else: tmp = t_1 * math.sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * sqrt(2.0)) tmp = 0.0 if (l <= 1.05e+130) tmp = sqrt(Float64(Float64(-4.0 * Float64(Float64(U * Float64(n * (l ^ 2.0))) / Om)) + Float64(2.0 * Float64(U * Float64(n * t))))); elseif (l <= 2.45e+207) tmp = Float64(t_1 * sqrt(Float64(U * Float64(Float64(n / Om) * Float64(-2.0 + Float64(Float64(n / Om) * Float64(U_42_ - U))))))); elseif (l <= 2.5e+244) tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(l * Float64(n * Float64(Float64(Float64(n * U_42_) / Om) - 2.0))) / Om))))); else tmp = Float64(t_1 * sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 2.0))) / Om))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = l * sqrt(2.0); tmp = 0.0; if (l <= 1.05e+130) tmp = sqrt(((-4.0 * ((U * (n * (l ^ 2.0))) / Om)) + (2.0 * (U * (n * t))))); elseif (l <= 2.45e+207) tmp = t_1 * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U)))))); elseif (l <= 2.5e+244) tmp = sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om))))); else tmp = t_1 * sqrt(((U * (n * (((n * (U_42_ - U)) / Om) - 2.0))) / Om)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 1.05e+130], N[Sqrt[N[(N[(-4.0 * N[(N[(U * N[(n * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 2.45e+207], N[(t$95$1 * N[Sqrt[N[(U * N[(N[(n / Om), $MachinePrecision] * N[(-2.0 + N[(N[(n / Om), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 2.5e+244], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(l * N[(n * N[(N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(t$95$1 * N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \sqrt{2}\\
\mathbf{if}\;\ell \leq 1.05 \cdot 10^{+130}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot {\ell}^{2}\right)}{Om} + 2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.45 \cdot 10^{+207}:\\
\;\;\;\;t_1 \cdot \sqrt{U \cdot \left(\frac{n}{Om} \cdot \left(-2 + \frac{n}{Om} \cdot \left(U* - U\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.5 \cdot 10^{+244}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \frac{\ell \cdot \left(n \cdot \left(\frac{n \cdot U*}{Om} - 2\right)\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 1.04999999999999995e130Initial program 50.8%
Simplified51.0%
Taylor expanded in Om around inf 45.5%
if 1.04999999999999995e130 < l < 2.45e207Initial program 29.0%
Simplified50.4%
Taylor expanded in l around inf 30.2%
unpow230.2%
sub-neg30.2%
unpow230.2%
times-frac31.0%
associate-*r/31.0%
metadata-eval31.0%
distribute-neg-frac31.0%
metadata-eval31.0%
Simplified31.0%
Taylor expanded in l around 0 44.5%
*-commutative44.5%
sub-neg44.5%
unpow244.5%
times-frac58.4%
distribute-rgt-in58.4%
associate-*r/58.4%
metadata-eval58.4%
distribute-neg-frac58.4%
metadata-eval58.4%
Simplified71.8%
if 2.45e207 < l < 2.50000000000000011e244Initial program 20.3%
Simplified30.8%
Taylor expanded in l around inf 41.0%
unpow241.0%
sub-neg41.0%
unpow241.0%
times-frac41.0%
associate-*r/41.0%
metadata-eval41.0%
distribute-neg-frac41.0%
metadata-eval41.0%
Simplified41.0%
Taylor expanded in l around 0 41.0%
unpow241.0%
unpow241.0%
times-frac41.0%
fma-neg41.0%
associate-*r/41.0%
metadata-eval41.0%
distribute-neg-frac41.0%
metadata-eval41.0%
associate-*r*61.4%
fma-udef61.4%
distribute-rgt-out41.4%
Simplified61.4%
Taylor expanded in U around 0 90.3%
if 2.50000000000000011e244 < l Initial program 14.0%
Simplified14.3%
Taylor expanded in l around inf 28.4%
unpow228.4%
sub-neg28.4%
unpow228.4%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.4%
unpow228.4%
unpow228.4%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*34.7%
fma-udef34.7%
distribute-rgt-out34.7%
Simplified34.7%
Taylor expanded in l around 0 72.5%
Final simplification50.4%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* n (- (/ (* n U*) Om) 2.0))))
(if (<= l 1.05e+131)
(sqrt (+ (* -4.0 (/ (* U (* n (pow l 2.0))) Om)) (* 2.0 (* U (* n t)))))
(if (<= l 3.9e+206)
(*
(sqrt 2.0)
(* l (sqrt (* U (* (/ n Om) (+ -2.0 (* (/ n Om) (- U* U))))))))
(if (<= l 6.4e+245)
(sqrt (* 2.0 (* U (* l (/ (* l t_1) Om)))))
(* (* l (sqrt 2.0)) (sqrt (/ (* U t_1) Om))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = n * (((n * U_42_) / Om) - 2.0);
double tmp;
if (l <= 1.05e+131) {
tmp = sqrt(((-4.0 * ((U * (n * pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 3.9e+206) {
tmp = sqrt(2.0) * (l * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U)))))));
} else if (l <= 6.4e+245) {
tmp = sqrt((2.0 * (U * (l * ((l * t_1) / Om)))));
} else {
tmp = (l * sqrt(2.0)) * sqrt(((U * t_1) / Om));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: t_1
real(8) :: tmp
t_1 = n * (((n * u_42) / om) - 2.0d0)
if (l <= 1.05d+131) then
tmp = sqrt((((-4.0d0) * ((u * (n * (l ** 2.0d0))) / om)) + (2.0d0 * (u * (n * t)))))
else if (l <= 3.9d+206) then
tmp = sqrt(2.0d0) * (l * sqrt((u * ((n / om) * ((-2.0d0) + ((n / om) * (u_42 - u)))))))
else if (l <= 6.4d+245) then
tmp = sqrt((2.0d0 * (u * (l * ((l * t_1) / om)))))
else
tmp = (l * sqrt(2.0d0)) * sqrt(((u * t_1) / om))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = n * (((n * U_42_) / Om) - 2.0);
double tmp;
if (l <= 1.05e+131) {
tmp = Math.sqrt(((-4.0 * ((U * (n * Math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else if (l <= 3.9e+206) {
tmp = Math.sqrt(2.0) * (l * Math.sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U)))))));
} else if (l <= 6.4e+245) {
tmp = Math.sqrt((2.0 * (U * (l * ((l * t_1) / Om)))));
} else {
tmp = (l * Math.sqrt(2.0)) * Math.sqrt(((U * t_1) / Om));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = n * (((n * U_42_) / Om) - 2.0) tmp = 0 if l <= 1.05e+131: tmp = math.sqrt(((-4.0 * ((U * (n * math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t))))) elif l <= 3.9e+206: tmp = math.sqrt(2.0) * (l * math.sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))))) elif l <= 6.4e+245: tmp = math.sqrt((2.0 * (U * (l * ((l * t_1) / Om))))) else: tmp = (l * math.sqrt(2.0)) * math.sqrt(((U * t_1) / Om)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(n * Float64(Float64(Float64(n * U_42_) / Om) - 2.0)) tmp = 0.0 if (l <= 1.05e+131) tmp = sqrt(Float64(Float64(-4.0 * Float64(Float64(U * Float64(n * (l ^ 2.0))) / Om)) + Float64(2.0 * Float64(U * Float64(n * t))))); elseif (l <= 3.9e+206) tmp = Float64(sqrt(2.0) * Float64(l * sqrt(Float64(U * Float64(Float64(n / Om) * Float64(-2.0 + Float64(Float64(n / Om) * Float64(U_42_ - U)))))))); elseif (l <= 6.4e+245) tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(l * t_1) / Om))))); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(Float64(U * t_1) / Om))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = n * (((n * U_42_) / Om) - 2.0); tmp = 0.0; if (l <= 1.05e+131) tmp = sqrt(((-4.0 * ((U * (n * (l ^ 2.0))) / Om)) + (2.0 * (U * (n * t))))); elseif (l <= 3.9e+206) tmp = sqrt(2.0) * (l * sqrt((U * ((n / Om) * (-2.0 + ((n / Om) * (U_42_ - U))))))); elseif (l <= 6.4e+245) tmp = sqrt((2.0 * (U * (l * ((l * t_1) / Om))))); else tmp = (l * sqrt(2.0)) * sqrt(((U * t_1) / Om)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(n * N[(N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 1.05e+131], N[Sqrt[N[(N[(-4.0 * N[(N[(U * N[(n * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.9e+206], N[(N[Sqrt[2.0], $MachinePrecision] * N[(l * N[Sqrt[N[(U * N[(N[(n / Om), $MachinePrecision] * N[(-2.0 + N[(N[(n / Om), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 6.4e+245], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(l * t$95$1), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(U * t$95$1), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := n \cdot \left(\frac{n \cdot U*}{Om} - 2\right)\\
\mathbf{if}\;\ell \leq 1.05 \cdot 10^{+131}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot {\ell}^{2}\right)}{Om} + 2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.9 \cdot 10^{+206}:\\
\;\;\;\;\sqrt{2} \cdot \left(\ell \cdot \sqrt{U \cdot \left(\frac{n}{Om} \cdot \left(-2 + \frac{n}{Om} \cdot \left(U* - U\right)\right)\right)}\right)\\
\mathbf{elif}\;\ell \leq 6.4 \cdot 10^{+245}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \frac{\ell \cdot t_1}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{\frac{U \cdot t_1}{Om}}\\
\end{array}
\end{array}
if l < 1.04999999999999993e131Initial program 50.8%
Simplified51.0%
Taylor expanded in Om around inf 45.5%
if 1.04999999999999993e131 < l < 3.9e206Initial program 29.0%
Simplified50.4%
sqrt-prod50.4%
Applied egg-rr50.4%
Taylor expanded in l around inf 44.5%
*-commutative44.5%
sub-neg44.5%
unpow244.5%
times-frac58.5%
distribute-rgt-in58.5%
associate-*r/58.5%
metadata-eval58.5%
distribute-neg-frac58.5%
metadata-eval58.5%
Simplified71.6%
if 3.9e206 < l < 6.40000000000000048e245Initial program 20.3%
Simplified30.8%
Taylor expanded in l around inf 41.0%
unpow241.0%
sub-neg41.0%
unpow241.0%
times-frac41.0%
associate-*r/41.0%
metadata-eval41.0%
distribute-neg-frac41.0%
metadata-eval41.0%
Simplified41.0%
Taylor expanded in l around 0 41.0%
unpow241.0%
unpow241.0%
times-frac41.0%
fma-neg41.0%
associate-*r/41.0%
metadata-eval41.0%
distribute-neg-frac41.0%
metadata-eval41.0%
associate-*r*61.4%
fma-udef61.4%
distribute-rgt-out41.4%
Simplified61.4%
Taylor expanded in U around 0 90.3%
if 6.40000000000000048e245 < l Initial program 14.0%
Simplified14.3%
Taylor expanded in l around inf 28.4%
unpow228.4%
sub-neg28.4%
unpow228.4%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.4%
unpow228.4%
unpow228.4%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*34.7%
fma-udef34.7%
distribute-rgt-out34.7%
Simplified34.7%
Taylor expanded in U around 0 46.9%
Taylor expanded in l around 0 72.2%
Final simplification50.3%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (fma (* l (/ l Om)) -2.0 t)))
(if (<= Om -6.5e-49)
(sqrt (* (* U (* 2.0 n)) t_1))
(if (<= Om 5.7e+21)
(* (* l (sqrt 2.0)) (sqrt (/ U (/ Om (* n (+ -2.0 (/ U* (/ Om n))))))))
(sqrt (* 2.0 (* U (* n t_1))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = fma((l * (l / Om)), -2.0, t);
double tmp;
if (Om <= -6.5e-49) {
tmp = sqrt(((U * (2.0 * n)) * t_1));
} else if (Om <= 5.7e+21) {
tmp = (l * sqrt(2.0)) * sqrt((U / (Om / (n * (-2.0 + (U_42_ / (Om / n)))))));
} else {
tmp = sqrt((2.0 * (U * (n * t_1))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = fma(Float64(l * Float64(l / Om)), -2.0, t) tmp = 0.0 if (Om <= -6.5e-49) tmp = sqrt(Float64(Float64(U * Float64(2.0 * n)) * t_1)); elseif (Om <= 5.7e+21) tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(U / Float64(Om / Float64(n * Float64(-2.0 + Float64(U_42_ / Float64(Om / n)))))))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * t_1)))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * -2.0 + t), $MachinePrecision]}, If[LessEqual[Om, -6.5e-49], N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, 5.7e+21], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(U / N[(Om / N[(n * N[(-2.0 + N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\\
\mathbf{if}\;Om \leq -6.5 \cdot 10^{-49}:\\
\;\;\;\;\sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot t_1}\\
\mathbf{elif}\;Om \leq 5.7 \cdot 10^{+21}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{\frac{U}{\frac{Om}{n \cdot \left(-2 + \frac{U*}{\frac{Om}{n}}\right)}}}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot t_1\right)\right)}\\
\end{array}
\end{array}
if Om < -6.49999999999999968e-49Initial program 55.1%
associate-*l/66.3%
Applied egg-rr66.3%
Taylor expanded in Om around inf 52.9%
+-commutative52.9%
*-commutative52.9%
unpow252.9%
associate-*r/62.1%
fma-udef62.1%
Simplified62.1%
if -6.49999999999999968e-49 < Om < 5.7e21Initial program 33.9%
Simplified33.3%
Taylor expanded in l around inf 34.7%
unpow234.7%
sub-neg34.7%
unpow234.7%
times-frac35.9%
associate-*r/35.9%
metadata-eval35.9%
distribute-neg-frac35.9%
metadata-eval35.9%
Simplified35.9%
Taylor expanded in l around 0 34.7%
unpow234.7%
unpow234.7%
times-frac35.9%
fma-neg35.9%
associate-*r/35.9%
metadata-eval35.9%
distribute-neg-frac35.9%
metadata-eval35.9%
associate-*r*38.2%
fma-udef38.2%
distribute-rgt-out32.0%
Simplified46.1%
Taylor expanded in U around 0 46.3%
Taylor expanded in l around 0 25.2%
*-commutative25.2%
associate-/l*32.1%
sub-neg32.1%
*-commutative32.1%
metadata-eval32.1%
+-commutative32.1%
*-commutative32.1%
associate-/l*32.1%
Simplified32.1%
if 5.7e21 < Om Initial program 52.2%
associate-*l/59.4%
Applied egg-rr59.4%
Taylor expanded in n around 0 53.3%
cancel-sign-sub-inv53.3%
metadata-eval53.3%
+-commutative53.3%
*-commutative53.3%
unpow253.3%
associate-*r/60.1%
fma-udef60.1%
Simplified60.1%
Final simplification49.9%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 7.5e+129) (sqrt (+ (* -4.0 (/ (* U (* n (pow l 2.0))) Om)) (* 2.0 (* U (* n t))))) (* (* l (sqrt 2.0)) (sqrt (/ (* U (* n (- (/ (* n U*) Om) 2.0))) Om)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 7.5e+129) {
tmp = sqrt(((-4.0 * ((U * (n * pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else {
tmp = (l * sqrt(2.0)) * sqrt(((U * (n * (((n * U_42_) / Om) - 2.0))) / Om));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 7.5d+129) then
tmp = sqrt((((-4.0d0) * ((u * (n * (l ** 2.0d0))) / om)) + (2.0d0 * (u * (n * t)))))
else
tmp = (l * sqrt(2.0d0)) * sqrt(((u * (n * (((n * u_42) / om) - 2.0d0))) / om))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 7.5e+129) {
tmp = Math.sqrt(((-4.0 * ((U * (n * Math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t)))));
} else {
tmp = (l * Math.sqrt(2.0)) * Math.sqrt(((U * (n * (((n * U_42_) / Om) - 2.0))) / Om));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 7.5e+129: tmp = math.sqrt(((-4.0 * ((U * (n * math.pow(l, 2.0))) / Om)) + (2.0 * (U * (n * t))))) else: tmp = (l * math.sqrt(2.0)) * math.sqrt(((U * (n * (((n * U_42_) / Om) - 2.0))) / Om)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 7.5e+129) tmp = sqrt(Float64(Float64(-4.0 * Float64(Float64(U * Float64(n * (l ^ 2.0))) / Om)) + Float64(2.0 * Float64(U * Float64(n * t))))); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * U_42_) / Om) - 2.0))) / Om))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 7.5e+129) tmp = sqrt(((-4.0 * ((U * (n * (l ^ 2.0))) / Om)) + (2.0 * (U * (n * t))))); else tmp = (l * sqrt(2.0)) * sqrt(((U * (n * (((n * U_42_) / Om) - 2.0))) / Om)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 7.5e+129], N[Sqrt[N[(N[(-4.0 * N[(N[(U * N[(n * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 7.5 \cdot 10^{+129}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot {\ell}^{2}\right)}{Om} + 2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot U*}{Om} - 2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 7.4999999999999998e129Initial program 50.8%
Simplified51.0%
Taylor expanded in Om around inf 45.5%
if 7.4999999999999998e129 < l Initial program 20.8%
Simplified31.1%
Taylor expanded in l around inf 32.2%
unpow232.2%
sub-neg32.2%
unpow232.2%
times-frac32.5%
associate-*r/32.5%
metadata-eval32.5%
distribute-neg-frac32.5%
metadata-eval32.5%
Simplified32.5%
Taylor expanded in l around 0 32.2%
unpow232.2%
unpow232.2%
times-frac32.5%
fma-neg32.5%
associate-*r/32.5%
metadata-eval32.5%
distribute-neg-frac32.5%
metadata-eval32.5%
associate-*r*44.9%
fma-udef44.9%
distribute-rgt-out39.9%
Simplified45.0%
Taylor expanded in U around 0 59.5%
Taylor expanded in l around 0 63.2%
Final simplification48.3%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 1.05e+154) (sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t))))) (* (* l (sqrt 2.0)) (sqrt (/ (* U (* n (- (/ (* n U*) Om) 2.0))) Om)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.05e+154) {
tmp = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
} else {
tmp = (l * sqrt(2.0)) * sqrt(((U * (n * (((n * U_42_) / Om) - 2.0))) / Om));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.05e+154) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))); else tmp = Float64(Float64(l * sqrt(2.0)) * sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * U_42_) / Om) - 2.0))) / Om))); end return tmp end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.05e+154], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * -2.0 + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.05 \cdot 10^{+154}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \sqrt{2}\right) \cdot \sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot U*}{Om} - 2\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 1.04999999999999997e154Initial program 51.0%
associate-*l/55.4%
Applied egg-rr55.4%
Taylor expanded in n around 0 45.9%
cancel-sign-sub-inv45.9%
metadata-eval45.9%
+-commutative45.9%
*-commutative45.9%
unpow245.9%
associate-*r/49.4%
fma-udef49.4%
Simplified49.4%
if 1.04999999999999997e154 < l Initial program 15.3%
Simplified32.5%
Taylor expanded in l around inf 28.1%
unpow228.1%
sub-neg28.1%
unpow228.1%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.1%
unpow228.1%
unpow228.1%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*42.7%
fma-udef42.7%
distribute-rgt-out37.0%
Simplified42.7%
Taylor expanded in U around 0 59.0%
Taylor expanded in l around 0 65.9%
Final simplification51.7%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 4.5e+119)
(sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t)))))
(sqrt
(* 2.0 (* U (* l (* (/ 1.0 Om) (* (* n l) (+ -2.0 (/ U* (/ Om n)))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 4.5e+119) {
tmp = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
} else {
tmp = sqrt((2.0 * (U * (l * ((1.0 / Om) * ((n * l) * (-2.0 + (U_42_ / (Om / n)))))))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 4.5e+119) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(1.0 / Om) * Float64(Float64(n * l) * Float64(-2.0 + Float64(U_42_ / Float64(Om / n))))))))); end return tmp end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 4.5e+119], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * -2.0 + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(1.0 / Om), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(-2.0 + N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 4.5 \cdot 10^{+119}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \left(\frac{1}{Om} \cdot \left(\left(n \cdot \ell\right) \cdot \left(-2 + \frac{U*}{\frac{Om}{n}}\right)\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 4.5000000000000002e119Initial program 51.0%
associate-*l/55.6%
Applied egg-rr55.6%
Taylor expanded in n around 0 46.2%
cancel-sign-sub-inv46.2%
metadata-eval46.2%
+-commutative46.2%
*-commutative46.2%
unpow246.2%
associate-*r/49.8%
fma-udef49.8%
Simplified49.8%
if 4.5000000000000002e119 < l Initial program 20.3%
Simplified30.3%
Taylor expanded in l around inf 33.9%
unpow233.9%
sub-neg33.9%
unpow233.9%
times-frac34.1%
associate-*r/34.1%
metadata-eval34.1%
distribute-neg-frac34.1%
metadata-eval34.1%
Simplified34.1%
Taylor expanded in l around 0 33.9%
unpow233.9%
unpow233.9%
times-frac34.1%
fma-neg34.1%
associate-*r/34.1%
metadata-eval34.1%
distribute-neg-frac34.1%
metadata-eval34.1%
associate-*r*46.3%
fma-udef46.3%
distribute-rgt-out41.4%
Simplified46.3%
Taylor expanded in U around 0 60.4%
div-inv60.4%
sub-neg60.4%
*-commutative60.4%
metadata-eval60.4%
Applied egg-rr60.4%
*-commutative60.4%
associate-*r*60.4%
+-commutative60.4%
*-commutative60.4%
associate-/l*60.4%
Simplified60.4%
Final simplification51.5%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 1.45e+119)
(sqrt (* (- t (* 2.0 (/ (* l l) Om))) (* 2.0 (* n U))))
(sqrt
(* 2.0 (* U (* l (* (/ 1.0 Om) (* (* n l) (+ -2.0 (/ U* (/ Om n)))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.45e+119) {
tmp = sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U))));
} else {
tmp = sqrt((2.0 * (U * (l * ((1.0 / Om) * ((n * l) * (-2.0 + (U_42_ / (Om / n)))))))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.45d+119) then
tmp = sqrt(((t - (2.0d0 * ((l * l) / om))) * (2.0d0 * (n * u))))
else
tmp = sqrt((2.0d0 * (u * (l * ((1.0d0 / om) * ((n * l) * ((-2.0d0) + (u_42 / (om / n)))))))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.45e+119) {
tmp = Math.sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U))));
} else {
tmp = Math.sqrt((2.0 * (U * (l * ((1.0 / Om) * ((n * l) * (-2.0 + (U_42_ / (Om / n)))))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.45e+119: tmp = math.sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U)))) else: tmp = math.sqrt((2.0 * (U * (l * ((1.0 / Om) * ((n * l) * (-2.0 + (U_42_ / (Om / n))))))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.45e+119) tmp = sqrt(Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) * Float64(2.0 * Float64(n * U)))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(1.0 / Om) * Float64(Float64(n * l) * Float64(-2.0 + Float64(U_42_ / Float64(Om / n))))))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.45e+119) tmp = sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U)))); else tmp = sqrt((2.0 * (U * (l * ((1.0 / Om) * ((n * l) * (-2.0 + (U_42_ / (Om / n))))))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.45e+119], N[Sqrt[N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(1.0 / Om), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(-2.0 + N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.45 \cdot 10^{+119}:\\
\;\;\;\;\sqrt{\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) \cdot \left(2 \cdot \left(n \cdot U\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \left(\frac{1}{Om} \cdot \left(\left(n \cdot \ell\right) \cdot \left(-2 + \frac{U*}{\frac{Om}{n}}\right)\right)\right)\right)\right)}\\
\end{array}
\end{array}
if l < 1.45000000000000004e119Initial program 51.0%
Simplified51.2%
Taylor expanded in Om around inf 45.0%
unpow245.0%
Simplified45.0%
if 1.45000000000000004e119 < l Initial program 20.3%
Simplified30.3%
Taylor expanded in l around inf 33.9%
unpow233.9%
sub-neg33.9%
unpow233.9%
times-frac34.1%
associate-*r/34.1%
metadata-eval34.1%
distribute-neg-frac34.1%
metadata-eval34.1%
Simplified34.1%
Taylor expanded in l around 0 33.9%
unpow233.9%
unpow233.9%
times-frac34.1%
fma-neg34.1%
associate-*r/34.1%
metadata-eval34.1%
distribute-neg-frac34.1%
metadata-eval34.1%
associate-*r*46.3%
fma-udef46.3%
distribute-rgt-out41.4%
Simplified46.3%
Taylor expanded in U around 0 60.4%
div-inv60.4%
sub-neg60.4%
*-commutative60.4%
metadata-eval60.4%
Applied egg-rr60.4%
*-commutative60.4%
associate-*r*60.4%
+-commutative60.4%
*-commutative60.4%
associate-/l*60.4%
Simplified60.4%
Final simplification47.5%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 1.15e+119) (sqrt (* (- t (* 2.0 (/ (* l l) Om))) (* 2.0 (* n U)))) (sqrt (* 2.0 (* U (* l (/ (* l (* n (- (/ (* n U*) Om) 2.0))) Om)))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.15e+119) {
tmp = sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U))));
} else {
tmp = sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.15d+119) then
tmp = sqrt(((t - (2.0d0 * ((l * l) / om))) * (2.0d0 * (n * u))))
else
tmp = sqrt((2.0d0 * (u * (l * ((l * (n * (((n * u_42) / om) - 2.0d0))) / om)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.15e+119) {
tmp = Math.sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U))));
} else {
tmp = Math.sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.15e+119: tmp = math.sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U)))) else: tmp = math.sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.15e+119) tmp = sqrt(Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) * Float64(2.0 * Float64(n * U)))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(l * Float64(n * Float64(Float64(Float64(n * U_42_) / Om) - 2.0))) / Om))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.15e+119) tmp = sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U)))); else tmp = sqrt((2.0 * (U * (l * ((l * (n * (((n * U_42_) / Om) - 2.0))) / Om))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.15e+119], N[Sqrt[N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(l * N[(n * N[(N[(N[(n * U$42$), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.15 \cdot 10^{+119}:\\
\;\;\;\;\sqrt{\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) \cdot \left(2 \cdot \left(n \cdot U\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \frac{\ell \cdot \left(n \cdot \left(\frac{n \cdot U*}{Om} - 2\right)\right)}{Om}\right)\right)}\\
\end{array}
\end{array}
if l < 1.15e119Initial program 51.0%
Simplified51.2%
Taylor expanded in Om around inf 45.0%
unpow245.0%
Simplified45.0%
if 1.15e119 < l Initial program 20.3%
Simplified30.3%
Taylor expanded in l around inf 33.9%
unpow233.9%
sub-neg33.9%
unpow233.9%
times-frac34.1%
associate-*r/34.1%
metadata-eval34.1%
distribute-neg-frac34.1%
metadata-eval34.1%
Simplified34.1%
Taylor expanded in l around 0 33.9%
unpow233.9%
unpow233.9%
times-frac34.1%
fma-neg34.1%
associate-*r/34.1%
metadata-eval34.1%
distribute-neg-frac34.1%
metadata-eval34.1%
associate-*r*46.3%
fma-udef46.3%
distribute-rgt-out41.4%
Simplified46.3%
Taylor expanded in U around 0 60.4%
Final simplification47.5%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= Om -9.5e+73)
(pow (* (* U (* 2.0 n)) t) 0.5)
(if (<= Om 3.5e-226)
(sqrt (* 2.0 (* -2.0 (/ U (/ Om (* n (* l l)))))))
(sqrt (* (* 2.0 n) (* U t))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= -9.5e+73) {
tmp = pow(((U * (2.0 * n)) * t), 0.5);
} else if (Om <= 3.5e-226) {
tmp = sqrt((2.0 * (-2.0 * (U / (Om / (n * (l * l)))))));
} else {
tmp = sqrt(((2.0 * n) * (U * t)));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (om <= (-9.5d+73)) then
tmp = ((u * (2.0d0 * n)) * t) ** 0.5d0
else if (om <= 3.5d-226) then
tmp = sqrt((2.0d0 * ((-2.0d0) * (u / (om / (n * (l * l)))))))
else
tmp = sqrt(((2.0d0 * n) * (u * t)))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= -9.5e+73) {
tmp = Math.pow(((U * (2.0 * n)) * t), 0.5);
} else if (Om <= 3.5e-226) {
tmp = Math.sqrt((2.0 * (-2.0 * (U / (Om / (n * (l * l)))))));
} else {
tmp = Math.sqrt(((2.0 * n) * (U * t)));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if Om <= -9.5e+73: tmp = math.pow(((U * (2.0 * n)) * t), 0.5) elif Om <= 3.5e-226: tmp = math.sqrt((2.0 * (-2.0 * (U / (Om / (n * (l * l))))))) else: tmp = math.sqrt(((2.0 * n) * (U * t))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (Om <= -9.5e+73) tmp = Float64(Float64(U * Float64(2.0 * n)) * t) ^ 0.5; elseif (Om <= 3.5e-226) tmp = sqrt(Float64(2.0 * Float64(-2.0 * Float64(U / Float64(Om / Float64(n * Float64(l * l))))))); else tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * t))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (Om <= -9.5e+73) tmp = ((U * (2.0 * n)) * t) ^ 0.5; elseif (Om <= 3.5e-226) tmp = sqrt((2.0 * (-2.0 * (U / (Om / (n * (l * l))))))); else tmp = sqrt(((2.0 * n) * (U * t))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[Om, -9.5e+73], N[Power[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], 0.5], $MachinePrecision], If[LessEqual[Om, 3.5e-226], N[Sqrt[N[(2.0 * N[(-2.0 * N[(U / N[(Om / N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -9.5 \cdot 10^{+73}:\\
\;\;\;\;{\left(\left(U \cdot \left(2 \cdot n\right)\right) \cdot t\right)}^{0.5}\\
\mathbf{elif}\;Om \leq 3.5 \cdot 10^{-226}:\\
\;\;\;\;\sqrt{2 \cdot \left(-2 \cdot \frac{U}{\frac{Om}{n \cdot \left(\ell \cdot \ell\right)}}\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot t\right)}\\
\end{array}
\end{array}
if Om < -9.4999999999999996e73Initial program 53.9%
associate-*l/67.9%
Applied egg-rr67.9%
Taylor expanded in t around inf 44.8%
pow1/246.4%
*-commutative46.4%
*-commutative46.4%
*-commutative46.4%
Applied egg-rr46.4%
if -9.4999999999999996e73 < Om < 3.5e-226Initial program 41.1%
Simplified36.1%
Taylor expanded in l around inf 41.5%
unpow241.5%
sub-neg41.5%
unpow241.5%
times-frac44.4%
associate-*r/44.4%
metadata-eval44.4%
distribute-neg-frac44.4%
metadata-eval44.4%
Simplified44.4%
Taylor expanded in n around 0 31.6%
associate-/l*34.1%
*-commutative34.1%
unpow234.1%
Simplified34.1%
if 3.5e-226 < Om Initial program 44.6%
associate-*l/48.9%
Applied egg-rr48.9%
Taylor expanded in t around inf 36.2%
*-un-lft-identity36.2%
*-commutative36.2%
*-commutative36.2%
*-commutative36.2%
Applied egg-rr36.2%
*-lft-identity36.2%
associate-*r*41.6%
Simplified41.6%
Final simplification40.8%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 1.05e+154) (sqrt (* (- t (* 2.0 (/ (* l l) Om))) (* 2.0 (* n U)))) (sqrt (* 2.0 (* U (* l (/ (* -2.0 (* n l)) Om)))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.05e+154) {
tmp = sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U))));
} else {
tmp = sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.05d+154) then
tmp = sqrt(((t - (2.0d0 * ((l * l) / om))) * (2.0d0 * (n * u))))
else
tmp = sqrt((2.0d0 * (u * (l * (((-2.0d0) * (n * l)) / om)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.05e+154) {
tmp = Math.sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U))));
} else {
tmp = Math.sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.05e+154: tmp = math.sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U)))) else: tmp = math.sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.05e+154) tmp = sqrt(Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) * Float64(2.0 * Float64(n * U)))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(-2.0 * Float64(n * l)) / Om))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.05e+154) tmp = sqrt(((t - (2.0 * ((l * l) / Om))) * (2.0 * (n * U)))); else tmp = sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.05e+154], N[Sqrt[N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(-2.0 * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.05 \cdot 10^{+154}:\\
\;\;\;\;\sqrt{\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) \cdot \left(2 \cdot \left(n \cdot U\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \frac{-2 \cdot \left(n \cdot \ell\right)}{Om}\right)\right)}\\
\end{array}
\end{array}
if l < 1.04999999999999997e154Initial program 51.0%
Simplified51.2%
Taylor expanded in Om around inf 44.7%
unpow244.7%
Simplified44.7%
if 1.04999999999999997e154 < l Initial program 15.3%
Simplified32.5%
Taylor expanded in l around inf 28.1%
unpow228.1%
sub-neg28.1%
unpow228.1%
times-frac28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
Simplified28.4%
Taylor expanded in l around 0 28.1%
unpow228.1%
unpow228.1%
times-frac28.4%
fma-neg28.4%
associate-*r/28.4%
metadata-eval28.4%
distribute-neg-frac28.4%
metadata-eval28.4%
associate-*r*42.7%
fma-udef42.7%
distribute-rgt-out37.0%
Simplified42.7%
Taylor expanded in n around 0 47.1%
associate-*r/47.1%
Simplified47.1%
Final simplification45.0%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 1.35e+67) (pow (* 2.0 (* U (* n t))) 0.5) (sqrt (* 2.0 (* U (* l (/ (* l -2.0) (/ Om n))))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.35e+67) {
tmp = pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = sqrt((2.0 * (U * (l * ((l * -2.0) / (Om / n))))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.35d+67) then
tmp = (2.0d0 * (u * (n * t))) ** 0.5d0
else
tmp = sqrt((2.0d0 * (u * (l * ((l * (-2.0d0)) / (om / n))))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.35e+67) {
tmp = Math.pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = Math.sqrt((2.0 * (U * (l * ((l * -2.0) / (Om / n))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.35e+67: tmp = math.pow((2.0 * (U * (n * t))), 0.5) else: tmp = math.sqrt((2.0 * (U * (l * ((l * -2.0) / (Om / n)))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.35e+67) tmp = Float64(2.0 * Float64(U * Float64(n * t))) ^ 0.5; else tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(l * -2.0) / Float64(Om / n)))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.35e+67) tmp = (2.0 * (U * (n * t))) ^ 0.5; else tmp = sqrt((2.0 * (U * (l * ((l * -2.0) / (Om / n)))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.35e+67], N[Power[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(l * -2.0), $MachinePrecision] / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.35 \cdot 10^{+67}:\\
\;\;\;\;{\left(2 \cdot \left(U \cdot \left(n \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \frac{\ell \cdot -2}{\frac{Om}{n}}\right)\right)}\\
\end{array}
\end{array}
if l < 1.35e67Initial program 50.1%
Simplified54.5%
Taylor expanded in l around 0 39.4%
pow1/240.9%
Applied egg-rr40.9%
if 1.35e67 < l Initial program 30.9%
Simplified38.6%
Taylor expanded in l around inf 35.5%
unpow235.5%
sub-neg35.5%
unpow235.5%
times-frac37.7%
associate-*r/37.7%
metadata-eval37.7%
distribute-neg-frac37.7%
metadata-eval37.7%
Simplified37.7%
Taylor expanded in l around 0 35.5%
unpow235.5%
unpow235.5%
times-frac37.7%
fma-neg37.7%
associate-*r/37.7%
metadata-eval37.7%
distribute-neg-frac37.7%
metadata-eval37.7%
associate-*r*47.2%
fma-udef47.2%
distribute-rgt-out43.4%
Simplified47.2%
Taylor expanded in U around 0 58.6%
Taylor expanded in n around 0 48.4%
associate-/l*34.0%
associate-*r/34.0%
Simplified34.0%
Final simplification39.5%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 4.8e+67) (pow (* 2.0 (* U (* n t))) 0.5) (sqrt (* 2.0 (* U (* l (/ (* -2.0 (* n l)) Om)))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 4.8e+67) {
tmp = pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 4.8d+67) then
tmp = (2.0d0 * (u * (n * t))) ** 0.5d0
else
tmp = sqrt((2.0d0 * (u * (l * (((-2.0d0) * (n * l)) / om)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 4.8e+67) {
tmp = Math.pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = Math.sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 4.8e+67: tmp = math.pow((2.0 * (U * (n * t))), 0.5) else: tmp = math.sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 4.8e+67) tmp = Float64(2.0 * Float64(U * Float64(n * t))) ^ 0.5; else tmp = sqrt(Float64(2.0 * Float64(U * Float64(l * Float64(Float64(-2.0 * Float64(n * l)) / Om))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 4.8e+67) tmp = (2.0 * (U * (n * t))) ^ 0.5; else tmp = sqrt((2.0 * (U * (l * ((-2.0 * (n * l)) / Om))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 4.8e+67], N[Power[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(l * N[(N[(-2.0 * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 4.8 \cdot 10^{+67}:\\
\;\;\;\;{\left(2 \cdot \left(U \cdot \left(n \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\ell \cdot \frac{-2 \cdot \left(n \cdot \ell\right)}{Om}\right)\right)}\\
\end{array}
\end{array}
if l < 4.80000000000000004e67Initial program 50.1%
Simplified54.5%
Taylor expanded in l around 0 39.4%
pow1/240.9%
Applied egg-rr40.9%
if 4.80000000000000004e67 < l Initial program 30.9%
Simplified38.6%
Taylor expanded in l around inf 35.5%
unpow235.5%
sub-neg35.5%
unpow235.5%
times-frac37.7%
associate-*r/37.7%
metadata-eval37.7%
distribute-neg-frac37.7%
metadata-eval37.7%
Simplified37.7%
Taylor expanded in l around 0 35.5%
unpow235.5%
unpow235.5%
times-frac37.7%
fma-neg37.7%
associate-*r/37.7%
metadata-eval37.7%
distribute-neg-frac37.7%
metadata-eval37.7%
associate-*r*47.2%
fma-udef47.2%
distribute-rgt-out43.4%
Simplified47.2%
Taylor expanded in n around 0 48.4%
associate-*r/48.4%
Simplified48.4%
Final simplification42.5%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 1.7e+69) (pow (* 2.0 (* U (* n t))) 0.5) (sqrt (* -4.0 (/ (* U (* n (* l l))) Om)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.7e+69) {
tmp = pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = sqrt((-4.0 * ((U * (n * (l * l))) / Om)));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.7d+69) then
tmp = (2.0d0 * (u * (n * t))) ** 0.5d0
else
tmp = sqrt(((-4.0d0) * ((u * (n * (l * l))) / om)))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.7e+69) {
tmp = Math.pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = Math.sqrt((-4.0 * ((U * (n * (l * l))) / Om)));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.7e+69: tmp = math.pow((2.0 * (U * (n * t))), 0.5) else: tmp = math.sqrt((-4.0 * ((U * (n * (l * l))) / Om))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.7e+69) tmp = Float64(2.0 * Float64(U * Float64(n * t))) ^ 0.5; else tmp = sqrt(Float64(-4.0 * Float64(Float64(U * Float64(n * Float64(l * l))) / Om))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.7e+69) tmp = (2.0 * (U * (n * t))) ^ 0.5; else tmp = sqrt((-4.0 * ((U * (n * (l * l))) / Om))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.7e+69], N[Power[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(-4.0 * N[(N[(U * N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.7 \cdot 10^{+69}:\\
\;\;\;\;{\left(2 \cdot \left(U \cdot \left(n \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{-4 \cdot \frac{U \cdot \left(n \cdot \left(\ell \cdot \ell\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 1.69999999999999993e69Initial program 50.1%
Simplified54.5%
Taylor expanded in l around 0 39.4%
pow1/240.9%
Applied egg-rr40.9%
if 1.69999999999999993e69 < l Initial program 30.9%
associate-*l/40.3%
Applied egg-rr40.3%
Taylor expanded in Om around inf 27.8%
+-commutative27.8%
*-commutative27.8%
unpow227.8%
associate-*r/35.8%
fma-udef35.8%
Simplified35.8%
Taylor expanded in l around inf 32.2%
unpow232.2%
Simplified32.2%
Final simplification39.1%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= Om 2e-71) (pow (* (* U (* 2.0 n)) t) 0.5) (sqrt (* (* 2.0 n) (* U t)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= 2e-71) {
tmp = pow(((U * (2.0 * n)) * t), 0.5);
} else {
tmp = sqrt(((2.0 * n) * (U * t)));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (om <= 2d-71) then
tmp = ((u * (2.0d0 * n)) * t) ** 0.5d0
else
tmp = sqrt(((2.0d0 * n) * (u * t)))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= 2e-71) {
tmp = Math.pow(((U * (2.0 * n)) * t), 0.5);
} else {
tmp = Math.sqrt(((2.0 * n) * (U * t)));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if Om <= 2e-71: tmp = math.pow(((U * (2.0 * n)) * t), 0.5) else: tmp = math.sqrt(((2.0 * n) * (U * t))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (Om <= 2e-71) tmp = Float64(Float64(U * Float64(2.0 * n)) * t) ^ 0.5; else tmp = sqrt(Float64(Float64(2.0 * n) * Float64(U * t))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (Om <= 2e-71) tmp = ((U * (2.0 * n)) * t) ^ 0.5; else tmp = sqrt(((2.0 * n) * (U * t))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[Om, 2e-71], N[Power[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(N[(2.0 * n), $MachinePrecision] * N[(U * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;Om \leq 2 \cdot 10^{-71}:\\
\;\;\;\;{\left(\left(U \cdot \left(2 \cdot n\right)\right) \cdot t\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot n\right) \cdot \left(U \cdot t\right)}\\
\end{array}
\end{array}
if Om < 1.9999999999999998e-71Initial program 45.1%
associate-*l/51.0%
Applied egg-rr51.0%
Taylor expanded in t around inf 27.3%
pow1/230.4%
*-commutative30.4%
*-commutative30.4%
*-commutative30.4%
Applied egg-rr30.4%
if 1.9999999999999998e-71 < Om Initial program 47.9%
associate-*l/53.5%
Applied egg-rr53.5%
Taylor expanded in t around inf 41.5%
*-un-lft-identity41.5%
*-commutative41.5%
*-commutative41.5%
*-commutative41.5%
Applied egg-rr41.5%
*-lft-identity41.5%
associate-*r*47.5%
Simplified47.5%
Final simplification36.5%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (pow (* 2.0 (* U (* n t))) 0.5))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
return pow((2.0 * (U * (n * t))), 0.5);
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = (2.0d0 * (u * (n * t))) ** 0.5d0
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.pow((2.0 * (U * (n * t))), 0.5);
}
l = abs(l) def code(n, U, t, l, Om, U_42_): return math.pow((2.0 * (U * (n * t))), 0.5)
l = abs(l) function code(n, U, t, l, Om, U_42_) return Float64(2.0 * Float64(U * Float64(n * t))) ^ 0.5 end
l = abs(l) function tmp = code(n, U, t, l, Om, U_42_) tmp = (2.0 * (U * (n * t))) ^ 0.5; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := N[Power[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
{\left(2 \cdot \left(U \cdot \left(n \cdot t\right)\right)\right)}^{0.5}
\end{array}
Initial program 46.1%
Simplified51.3%
Taylor expanded in l around 0 33.3%
pow1/234.6%
Applied egg-rr34.6%
Final simplification34.6%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (sqrt (* 2.0 (* U (* n t)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((2.0 * (U * (n * t))));
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt((2.0d0 * (u * (n * t))))
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt((2.0 * (U * (n * t))));
}
l = abs(l) def code(n, U, t, l, Om, U_42_): return math.sqrt((2.0 * (U * (n * t))))
l = abs(l) function code(n, U, t, l, Om, U_42_) return sqrt(Float64(2.0 * Float64(U * Float64(n * t)))) end
l = abs(l) function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((2.0 * (U * (n * t)))); end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
\sqrt{2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}
\end{array}
Initial program 46.1%
Simplified51.3%
Taylor expanded in l around 0 33.3%
Final simplification33.3%
herbie shell --seed 2023283
(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*))))))