
(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 19 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 (* n (pow (/ l Om) 2.0)))
(t_2
(sqrt
(*
(* U (* 2.0 n))
(+ (- t (* 2.0 (/ (* l l) Om))) (* t_1 (- U* U)))))))
(if (<= t_2 0.0)
(sqrt (* 2.0 (* n (* U (fma t_1 (- U* U) (fma -2.0 (* l (/ l Om)) t))))))
(if (<= t_2 1e+144)
t_2
(*
(sqrt (* U (* n (+ (* (/ n Om) (/ (- U* U) Om)) (/ -2.0 Om)))))
(* l (sqrt 2.0)))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = n * pow((l / Om), 2.0);
double t_2 = sqrt(((U * (2.0 * n)) * ((t - (2.0 * ((l * l) / Om))) + (t_1 * (U_42_ - U)))));
double tmp;
if (t_2 <= 0.0) {
tmp = sqrt((2.0 * (n * (U * fma(t_1, (U_42_ - U), fma(-2.0, (l * (l / Om)), t))))));
} else if (t_2 <= 1e+144) {
tmp = t_2;
} else {
tmp = sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * sqrt(2.0));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(n * (Float64(l / Om) ^ 2.0)) t_2 = sqrt(Float64(Float64(U * Float64(2.0 * n)) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) + Float64(t_1 * Float64(U_42_ - U))))) tmp = 0.0 if (t_2 <= 0.0) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * fma(t_1, Float64(U_42_ - U), fma(-2.0, Float64(l * Float64(l / Om)), t)))))); elseif (t_2 <= 1e+144) tmp = t_2; else tmp = Float64(sqrt(Float64(U * Float64(n * Float64(Float64(Float64(n / Om) * Float64(Float64(U_42_ - U) / Om)) + Float64(-2.0 / Om))))) * Float64(l * sqrt(2.0))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$2, 0.0], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t$95$1 * N[(U$42$ - U), $MachinePrecision] + N[(-2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$2, 1e+144], t$95$2, N[(N[Sqrt[N[(U * N[(n * N[(N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\\
t_2 := \sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) + t_1 \cdot \left(U* - U\right)\right)}\\
\mathbf{if}\;t_2 \leq 0:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \mathsf{fma}\left(t_1, U* - U, \mathsf{fma}\left(-2, \ell \cdot \frac{\ell}{Om}, t\right)\right)\right)\right)}\\
\mathbf{elif}\;t_2 \leq 10^{+144}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(n \cdot \left(\frac{n}{Om} \cdot \frac{U* - U}{Om} + \frac{-2}{Om}\right)\right)} \cdot \left(\ell \cdot \sqrt{2}\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 13.7%
Simplified13.2%
pow113.2%
Applied egg-rr13.2%
unpow113.2%
associate-*l*30.2%
fma-def30.2%
associate-*r*39.9%
fma-udef39.9%
*-commutative39.9%
associate-*r/39.9%
unpow239.9%
+-commutative39.9%
fma-def40.0%
+-commutative40.0%
unpow240.0%
associate-*r/40.0%
fma-def40.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*))))) < 1.00000000000000002e144Initial program 96.5%
if 1.00000000000000002e144 < (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 20.1%
Simplified29.5%
Taylor expanded in l around inf 22.6%
sub-neg22.6%
unpow222.6%
times-frac26.4%
associate-*r/26.4%
metadata-eval26.4%
distribute-neg-frac26.4%
metadata-eval26.4%
Simplified26.4%
Final simplification53.2%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(*
(* U (* 2.0 n))
(+
(- t (* 2.0 (/ (* l l) Om)))
(* (* n (pow (/ l Om) 2.0)) (- U* U)))))))
(if (<= t_1 0.0)
(* (sqrt (* 2.0 n)) (sqrt (* U t)))
(if (<= t_1 1e+144)
t_1
(*
(sqrt (* U (* n (+ (* (/ n Om) (/ (- U* U) Om)) (/ -2.0 Om)))))
(* l (sqrt 2.0)))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((U * (2.0 * n)) * ((t - (2.0 * ((l * l) / Om))) + ((n * pow((l / Om), 2.0)) * (U_42_ - U)))));
double tmp;
if (t_1 <= 0.0) {
tmp = sqrt((2.0 * n)) * sqrt((U * t));
} else if (t_1 <= 1e+144) {
tmp = t_1;
} else {
tmp = sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * sqrt(2.0));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt(((u * (2.0d0 * n)) * ((t - (2.0d0 * ((l * l) / om))) + ((n * ((l / om) ** 2.0d0)) * (u_42 - u)))))
if (t_1 <= 0.0d0) then
tmp = sqrt((2.0d0 * n)) * sqrt((u * t))
else if (t_1 <= 1d+144) then
tmp = t_1
else
tmp = sqrt((u * (n * (((n / om) * ((u_42 - u) / om)) + ((-2.0d0) / om))))) * (l * sqrt(2.0d0))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((U * (2.0 * n)) * ((t - (2.0 * ((l * l) / Om))) + ((n * Math.pow((l / Om), 2.0)) * (U_42_ - U)))));
double tmp;
if (t_1 <= 0.0) {
tmp = Math.sqrt((2.0 * n)) * Math.sqrt((U * t));
} else if (t_1 <= 1e+144) {
tmp = t_1;
} else {
tmp = Math.sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * Math.sqrt(2.0));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((U * (2.0 * n)) * ((t - (2.0 * ((l * l) / Om))) + ((n * math.pow((l / Om), 2.0)) * (U_42_ - U))))) tmp = 0 if t_1 <= 0.0: tmp = math.sqrt((2.0 * n)) * math.sqrt((U * t)) elif t_1 <= 1e+144: tmp = t_1 else: tmp = math.sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * math.sqrt(2.0)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(U * Float64(2.0 * n)) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) + Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U_42_ - U))))) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(sqrt(Float64(2.0 * n)) * sqrt(Float64(U * t))); elseif (t_1 <= 1e+144) tmp = t_1; else tmp = Float64(sqrt(Float64(U * Float64(n * Float64(Float64(Float64(n / Om) * Float64(Float64(U_42_ - U) / Om)) + Float64(-2.0 / Om))))) * Float64(l * sqrt(2.0))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((U * (2.0 * n)) * ((t - (2.0 * ((l * l) / Om))) + ((n * ((l / Om) ^ 2.0)) * (U_42_ - U))))); tmp = 0.0; if (t_1 <= 0.0) tmp = sqrt((2.0 * n)) * sqrt((U * t)); elseif (t_1 <= 1e+144) tmp = t_1; else tmp = sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * sqrt(2.0)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[(N[Sqrt[N[(2.0 * n), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(U * t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+144], t$95$1, N[(N[Sqrt[N[(U * N[(n * N[(N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) + \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U* - U\right)\right)}\\
\mathbf{if}\;t_1 \leq 0:\\
\;\;\;\;\sqrt{2 \cdot n} \cdot \sqrt{U \cdot t}\\
\mathbf{elif}\;t_1 \leq 10^{+144}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(n \cdot \left(\frac{n}{Om} \cdot \frac{U* - U}{Om} + \frac{-2}{Om}\right)\right)} \cdot \left(\ell \cdot \sqrt{2}\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 13.7%
Simplified13.2%
Taylor expanded in l around 0 28.1%
associate-*r*13.7%
*-commutative13.7%
Simplified13.7%
*-un-lft-identity13.7%
associate-*l*28.1%
Applied egg-rr28.1%
*-lft-identity28.1%
associate-*r*28.1%
Simplified28.1%
sqrt-prod37.6%
*-commutative37.6%
Applied egg-rr37.6%
if 0.0 < (sqrt.f64 (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*))))) < 1.00000000000000002e144Initial program 96.5%
if 1.00000000000000002e144 < (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 20.1%
Simplified29.5%
Taylor expanded in l around inf 22.6%
sub-neg22.6%
unpow222.6%
times-frac26.4%
associate-*r/26.4%
metadata-eval26.4%
distribute-neg-frac26.4%
metadata-eval26.4%
Simplified26.4%
Final simplification52.8%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* (* n (pow (/ l Om) 2.0)) (- U U*)))
(t_2 (sqrt (* (* U (* 2.0 n)) (- (- t (* 2.0 (/ (* l l) Om))) t_1)))))
(if (<= t_2 0.0)
(sqrt (* 2.0 (* n (* U (- (fma -2.0 (* l (/ l Om)) t) t_1)))))
(if (<= t_2 1e+144)
t_2
(*
(sqrt (* U (* n (+ (* (/ n Om) (/ (- U* U) Om)) (/ -2.0 Om)))))
(* l (sqrt 2.0)))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = (n * pow((l / Om), 2.0)) * (U - U_42_);
double t_2 = sqrt(((U * (2.0 * n)) * ((t - (2.0 * ((l * l) / Om))) - t_1)));
double tmp;
if (t_2 <= 0.0) {
tmp = sqrt((2.0 * (n * (U * (fma(-2.0, (l * (l / Om)), t) - t_1)))));
} else if (t_2 <= 1e+144) {
tmp = t_2;
} else {
tmp = sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * sqrt(2.0));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U - U_42_)) t_2 = sqrt(Float64(Float64(U * Float64(2.0 * n)) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) - t_1))) tmp = 0.0 if (t_2 <= 0.0) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(fma(-2.0, Float64(l * Float64(l / Om)), t) - t_1))))); elseif (t_2 <= 1e+144) tmp = t_2; else tmp = Float64(sqrt(Float64(U * Float64(n * Float64(Float64(Float64(n / Om) * Float64(Float64(U_42_ - U) / Om)) + Float64(-2.0 / Om))))) * Float64(l * sqrt(2.0))); end return tmp end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(N[(U * N[(2.0 * n), $MachinePrecision]), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$2, 0.0], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(N[(-2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$2, 1e+144], t$95$2, N[(N[Sqrt[N[(U * N[(n * N[(N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U - U*\right)\\
t_2 := \sqrt{\left(U \cdot \left(2 \cdot n\right)\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) - t_1\right)}\\
\mathbf{if}\;t_2 \leq 0:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(\mathsf{fma}\left(-2, \ell \cdot \frac{\ell}{Om}, t\right) - t_1\right)\right)\right)}\\
\mathbf{elif}\;t_2 \leq 10^{+144}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(n \cdot \left(\frac{n}{Om} \cdot \frac{U* - U}{Om} + \frac{-2}{Om}\right)\right)} \cdot \left(\ell \cdot \sqrt{2}\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 13.7%
Simplified13.2%
pow113.2%
Applied egg-rr13.2%
unpow113.2%
associate-*l*30.2%
fma-def30.2%
associate-*r*39.9%
fma-udef39.9%
*-commutative39.9%
associate-*r/39.9%
unpow239.9%
+-commutative39.9%
fma-def40.0%
+-commutative40.0%
unpow240.0%
associate-*r/40.0%
fma-def40.0%
Simplified40.0%
fma-udef39.9%
Applied egg-rr39.9%
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*))))) < 1.00000000000000002e144Initial program 96.5%
if 1.00000000000000002e144 < (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 20.1%
Simplified29.5%
Taylor expanded in l around inf 22.6%
sub-neg22.6%
unpow222.6%
times-frac26.4%
associate-*r/26.4%
metadata-eval26.4%
distribute-neg-frac26.4%
metadata-eval26.4%
Simplified26.4%
Final simplification53.2%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t)))))))
(if (<= l 6.2e-80)
(sqrt (* 2.0 (* t (* n U))))
(if (<= l 3.8e-43)
(sqrt (* 2.0 (* n (* (/ (* U U*) Om) (* n (/ (* l l) Om))))))
(if (<= l 2.8e-37)
(* (sqrt (* 2.0 n)) (sqrt (* U t)))
(if (<= l 4.3e-26)
(sqrt (* (* (/ -2.0 Om) (/ U Om)) (* (* l l) (* n (* n (- U U*))))))
(if (<= l 8.8e+56)
t_1
(if (<= l 3.95e+139)
(sqrt
(*
2.0
(*
n
(*
U
(+
t
(*
(* l l)
(- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))
(if (or (<= l 2.8e+151) (not (<= l 2.7e+239)))
(*
(sqrt 2.0)
(*
l
(sqrt
(* (* n U) (- (/ n (/ (* Om Om) (- U* U))) (/ 2.0 Om))))))
t_1)))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
double tmp;
if (l <= 6.2e-80) {
tmp = sqrt((2.0 * (t * (n * U))));
} else if (l <= 3.8e-43) {
tmp = sqrt((2.0 * (n * (((U * U_42_) / Om) * (n * ((l * l) / Om))))));
} else if (l <= 2.8e-37) {
tmp = sqrt((2.0 * n)) * sqrt((U * t));
} else if (l <= 4.3e-26) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((l * l) * (n * (n * (U - U_42_))))));
} else if (l <= 8.8e+56) {
tmp = t_1;
} else if (l <= 3.95e+139) {
tmp = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
} else if ((l <= 2.8e+151) || !(l <= 2.7e+239)) {
tmp = sqrt(2.0) * (l * sqrt(((n * U) * ((n / ((Om * Om) / (U_42_ - U))) - (2.0 / Om)))));
} else {
tmp = t_1;
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))) tmp = 0.0 if (l <= 6.2e-80) tmp = sqrt(Float64(2.0 * Float64(t * Float64(n * U)))); elseif (l <= 3.8e-43) tmp = sqrt(Float64(2.0 * Float64(n * Float64(Float64(Float64(U * U_42_) / Om) * Float64(n * Float64(Float64(l * l) / Om)))))); elseif (l <= 2.8e-37) tmp = Float64(sqrt(Float64(2.0 * n)) * sqrt(Float64(U * t))); elseif (l <= 4.3e-26) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(l * l) * Float64(n * Float64(n * Float64(U - U_42_)))))); elseif (l <= 8.8e+56) tmp = t_1; elseif (l <= 3.95e+139) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))); elseif ((l <= 2.8e+151) || !(l <= 2.7e+239)) tmp = Float64(sqrt(2.0) * Float64(l * sqrt(Float64(Float64(n * U) * Float64(Float64(n / Float64(Float64(Om * Om) / Float64(U_42_ - U))) - Float64(2.0 / Om)))))); else tmp = 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[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * -2.0 + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, 6.2e-80], N[Sqrt[N[(2.0 * N[(t * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.8e-43], N[Sqrt[N[(2.0 * N[(n * N[(N[(N[(U * U$42$), $MachinePrecision] / Om), $MachinePrecision] * N[(n * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 2.8e-37], N[(N[Sqrt[N[(2.0 * n), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(U * t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 4.3e-26], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(l * l), $MachinePrecision] * N[(n * N[(n * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 8.8e+56], t$95$1, If[LessEqual[l, 3.95e+139], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[Or[LessEqual[l, 2.8e+151], N[Not[LessEqual[l, 2.7e+239]], $MachinePrecision]], N[(N[Sqrt[2.0], $MachinePrecision] * N[(l * N[Sqrt[N[(N[(n * U), $MachinePrecision] * N[(N[(n / N[(N[(Om * Om), $MachinePrecision] / N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{if}\;\ell \leq 6.2 \cdot 10^{-80}:\\
\;\;\;\;\sqrt{2 \cdot \left(t \cdot \left(n \cdot U\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.8 \cdot 10^{-43}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(\frac{U \cdot U*}{Om} \cdot \left(n \cdot \frac{\ell \cdot \ell}{Om}\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.8 \cdot 10^{-37}:\\
\;\;\;\;\sqrt{2 \cdot n} \cdot \sqrt{U \cdot t}\\
\mathbf{elif}\;\ell \leq 4.3 \cdot 10^{-26}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(n \cdot \left(n \cdot \left(U - U*\right)\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 8.8 \cdot 10^{+56}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq 3.95 \cdot 10^{+139}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 2.8 \cdot 10^{+151} \lor \neg \left(\ell \leq 2.7 \cdot 10^{+239}\right):\\
\;\;\;\;\sqrt{2} \cdot \left(\ell \cdot \sqrt{\left(n \cdot U\right) \cdot \left(\frac{n}{\frac{Om \cdot Om}{U* - U}} - \frac{2}{Om}\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if l < 6.20000000000000032e-80Initial program 49.7%
Simplified51.2%
Taylor expanded in l around 0 40.3%
associate-*r*41.4%
*-commutative41.4%
Simplified41.4%
if 6.20000000000000032e-80 < l < 3.7999999999999997e-43Initial program 65.1%
Simplified56.5%
pow156.5%
Applied egg-rr56.5%
unpow156.5%
associate-*l*47.7%
fma-def47.7%
associate-*r*56.4%
fma-udef56.4%
*-commutative56.4%
associate-*r/56.4%
unpow256.4%
+-commutative56.4%
fma-def56.4%
+-commutative56.4%
unpow256.4%
associate-*r/56.4%
fma-def56.4%
Simplified56.4%
fma-udef56.4%
Applied egg-rr56.4%
Taylor expanded in U* around inf 38.8%
associate-*r*39.0%
unpow239.0%
times-frac56.5%
associate-*l/56.5%
unpow256.5%
Simplified56.5%
if 3.7999999999999997e-43 < l < 2.8000000000000001e-37Initial program 51.1%
Simplified51.1%
Taylor expanded in l around 0 99.2%
associate-*r*51.1%
*-commutative51.1%
Simplified51.1%
*-un-lft-identity51.1%
associate-*l*99.2%
Applied egg-rr99.2%
*-lft-identity99.2%
associate-*r*99.2%
Simplified99.2%
sqrt-prod99.2%
*-commutative99.2%
Applied egg-rr99.2%
if 2.8000000000000001e-37 < l < 4.29999999999999988e-26Initial program 53.3%
Simplified53.3%
Taylor expanded in n around inf 53.3%
associate-/l*53.3%
associate-*r/53.3%
unpow253.3%
associate-*r*53.3%
unpow253.3%
unpow253.3%
Simplified53.3%
*-un-lft-identity53.3%
associate-/r/53.3%
*-commutative53.3%
associate-*l*53.3%
Applied egg-rr53.3%
*-lft-identity53.3%
times-frac53.3%
associate-*l*53.3%
Simplified53.3%
if 4.29999999999999988e-26 < l < 8.80000000000000063e56 or 2.79999999999999987e151 < l < 2.6999999999999999e239Initial program 32.6%
Simplified39.9%
Taylor expanded in n around 0 34.9%
metadata-eval34.9%
cancel-sign-sub-inv34.9%
cancel-sign-sub-inv34.9%
metadata-eval34.9%
+-commutative34.9%
unpow234.9%
associate-*r/48.4%
*-commutative48.4%
fma-udef48.4%
Simplified48.4%
if 8.80000000000000063e56 < l < 3.9500000000000001e139Initial program 41.7%
Simplified41.4%
pow141.4%
Applied egg-rr41.4%
unpow141.4%
associate-*l*42.0%
fma-def42.0%
associate-*r*48.5%
fma-udef48.5%
*-commutative48.5%
associate-*r/48.4%
unpow248.4%
+-commutative48.4%
fma-def48.4%
+-commutative48.4%
unpow248.4%
associate-*r/48.5%
fma-def48.5%
Simplified48.5%
Taylor expanded in l around 0 55.1%
unpow255.1%
unpow255.1%
associate-*r/55.1%
metadata-eval55.1%
Simplified55.1%
if 3.9500000000000001e139 < l < 2.79999999999999987e151 or 2.6999999999999999e239 < l Initial program 14.8%
Simplified21.2%
sqrt-prod21.2%
Applied egg-rr21.2%
Taylor expanded in l around inf 73.5%
*-commutative73.5%
associate-*r*79.9%
*-commutative79.9%
associate-/l*79.9%
unpow279.9%
associate-*r/79.9%
metadata-eval79.9%
Simplified79.9%
Final simplification46.5%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t)))))))
(if (<= l 2.4e-80)
(sqrt (* 2.0 (* t (* n U))))
(if (<= l 3.5e-43)
(sqrt (* 2.0 (* n (* (/ (* U U*) Om) (* n (/ (* l l) Om))))))
(if (<= l 3.2e-38)
(* (sqrt (* 2.0 n)) (sqrt (* U t)))
(if (<= l 4.8e-26)
(sqrt (* (* (/ -2.0 Om) (/ U Om)) (* (* l l) (* n (* n (- U U*))))))
(if (<= l 8.8e+56)
t_1
(if (<= l 8.2e+85)
(sqrt
(*
2.0
(*
n
(*
U
(+
t
(*
(* l l)
(- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))
(if (or (<= l 1.3e+151) (not (<= l 5.5e+216)))
(*
(sqrt
(* U (* n (+ (* (/ n Om) (/ (- U* U) Om)) (/ -2.0 Om)))))
(* l (sqrt 2.0)))
t_1)))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
double tmp;
if (l <= 2.4e-80) {
tmp = sqrt((2.0 * (t * (n * U))));
} else if (l <= 3.5e-43) {
tmp = sqrt((2.0 * (n * (((U * U_42_) / Om) * (n * ((l * l) / Om))))));
} else if (l <= 3.2e-38) {
tmp = sqrt((2.0 * n)) * sqrt((U * t));
} else if (l <= 4.8e-26) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((l * l) * (n * (n * (U - U_42_))))));
} else if (l <= 8.8e+56) {
tmp = t_1;
} else if (l <= 8.2e+85) {
tmp = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
} else if ((l <= 1.3e+151) || !(l <= 5.5e+216)) {
tmp = sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * sqrt(2.0));
} else {
tmp = t_1;
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))) tmp = 0.0 if (l <= 2.4e-80) tmp = sqrt(Float64(2.0 * Float64(t * Float64(n * U)))); elseif (l <= 3.5e-43) tmp = sqrt(Float64(2.0 * Float64(n * Float64(Float64(Float64(U * U_42_) / Om) * Float64(n * Float64(Float64(l * l) / Om)))))); elseif (l <= 3.2e-38) tmp = Float64(sqrt(Float64(2.0 * n)) * sqrt(Float64(U * t))); elseif (l <= 4.8e-26) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(l * l) * Float64(n * Float64(n * Float64(U - U_42_)))))); elseif (l <= 8.8e+56) tmp = t_1; elseif (l <= 8.2e+85) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))); elseif ((l <= 1.3e+151) || !(l <= 5.5e+216)) tmp = Float64(sqrt(Float64(U * Float64(n * Float64(Float64(Float64(n / Om) * Float64(Float64(U_42_ - U) / Om)) + Float64(-2.0 / Om))))) * Float64(l * sqrt(2.0))); else tmp = 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[Sqrt[N[(2.0 * N[(U * N[(n * N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * -2.0 + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[l, 2.4e-80], N[Sqrt[N[(2.0 * N[(t * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.5e-43], N[Sqrt[N[(2.0 * N[(n * N[(N[(N[(U * U$42$), $MachinePrecision] / Om), $MachinePrecision] * N[(n * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 3.2e-38], N[(N[Sqrt[N[(2.0 * n), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(U * t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 4.8e-26], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(l * l), $MachinePrecision] * N[(n * N[(n * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 8.8e+56], t$95$1, If[LessEqual[l, 8.2e+85], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[Or[LessEqual[l, 1.3e+151], N[Not[LessEqual[l, 5.5e+216]], $MachinePrecision]], N[(N[Sqrt[N[(U * N[(n * N[(N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{if}\;\ell \leq 2.4 \cdot 10^{-80}:\\
\;\;\;\;\sqrt{2 \cdot \left(t \cdot \left(n \cdot U\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.5 \cdot 10^{-43}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(\frac{U \cdot U*}{Om} \cdot \left(n \cdot \frac{\ell \cdot \ell}{Om}\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 3.2 \cdot 10^{-38}:\\
\;\;\;\;\sqrt{2 \cdot n} \cdot \sqrt{U \cdot t}\\
\mathbf{elif}\;\ell \leq 4.8 \cdot 10^{-26}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(n \cdot \left(n \cdot \left(U - U*\right)\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 8.8 \cdot 10^{+56}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;\ell \leq 8.2 \cdot 10^{+85}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;\ell \leq 1.3 \cdot 10^{+151} \lor \neg \left(\ell \leq 5.5 \cdot 10^{+216}\right):\\
\;\;\;\;\sqrt{U \cdot \left(n \cdot \left(\frac{n}{Om} \cdot \frac{U* - U}{Om} + \frac{-2}{Om}\right)\right)} \cdot \left(\ell \cdot \sqrt{2}\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if l < 2.3999999999999999e-80Initial program 49.7%
Simplified51.2%
Taylor expanded in l around 0 40.3%
associate-*r*41.4%
*-commutative41.4%
Simplified41.4%
if 2.3999999999999999e-80 < l < 3.49999999999999997e-43Initial program 65.1%
Simplified56.5%
pow156.5%
Applied egg-rr56.5%
unpow156.5%
associate-*l*47.7%
fma-def47.7%
associate-*r*56.4%
fma-udef56.4%
*-commutative56.4%
associate-*r/56.4%
unpow256.4%
+-commutative56.4%
fma-def56.4%
+-commutative56.4%
unpow256.4%
associate-*r/56.4%
fma-def56.4%
Simplified56.4%
fma-udef56.4%
Applied egg-rr56.4%
Taylor expanded in U* around inf 38.8%
associate-*r*39.0%
unpow239.0%
times-frac56.5%
associate-*l/56.5%
unpow256.5%
Simplified56.5%
if 3.49999999999999997e-43 < l < 3.19999999999999977e-38Initial program 51.1%
Simplified51.1%
Taylor expanded in l around 0 99.2%
associate-*r*51.1%
*-commutative51.1%
Simplified51.1%
*-un-lft-identity51.1%
associate-*l*99.2%
Applied egg-rr99.2%
*-lft-identity99.2%
associate-*r*99.2%
Simplified99.2%
sqrt-prod99.2%
*-commutative99.2%
Applied egg-rr99.2%
if 3.19999999999999977e-38 < l < 4.8000000000000002e-26Initial program 53.3%
Simplified53.3%
Taylor expanded in n around inf 53.3%
associate-/l*53.3%
associate-*r/53.3%
unpow253.3%
associate-*r*53.3%
unpow253.3%
unpow253.3%
Simplified53.3%
*-un-lft-identity53.3%
associate-/r/53.3%
*-commutative53.3%
associate-*l*53.3%
Applied egg-rr53.3%
*-lft-identity53.3%
times-frac53.3%
associate-*l*53.3%
Simplified53.3%
if 4.8000000000000002e-26 < l < 8.80000000000000063e56 or 1.30000000000000007e151 < l < 5.5e216Initial program 37.7%
Simplified42.2%
Taylor expanded in n around 0 40.1%
metadata-eval40.1%
cancel-sign-sub-inv40.1%
cancel-sign-sub-inv40.1%
metadata-eval40.1%
+-commutative40.1%
unpow240.1%
associate-*r/51.9%
*-commutative51.9%
fma-udef51.9%
Simplified51.9%
if 8.80000000000000063e56 < l < 8.19999999999999957e85Initial program 68.2%
Simplified66.7%
pow166.7%
Applied egg-rr66.7%
unpow166.7%
associate-*l*67.4%
fma-def67.4%
associate-*r*100.0%
fma-udef100.0%
*-commutative100.0%
associate-*r/99.5%
unpow299.5%
+-commutative99.5%
fma-def99.5%
+-commutative99.5%
unpow299.5%
associate-*r/100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in l around 0 99.5%
unpow299.5%
unpow299.5%
associate-*r/99.5%
metadata-eval99.5%
Simplified99.5%
if 8.19999999999999957e85 < l < 1.30000000000000007e151 or 5.5e216 < l Initial program 20.9%
Simplified27.2%
Taylor expanded in l around inf 56.7%
sub-neg56.7%
unpow256.7%
times-frac72.3%
associate-*r/72.3%
metadata-eval72.3%
distribute-neg-frac72.3%
metadata-eval72.3%
Simplified72.3%
Final simplification48.1%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* l (/ l Om))))
(if (<= l 5.4e+57)
(sqrt
(*
(* 2.0 U)
(* n (+ (fma -2.0 t_1 t) (* (/ n Om) (/ (* (* l l) U*) Om))))))
(if (or (<= l 4e+151) (not (<= l 5.8e+216)))
(*
(sqrt (* U (* n (+ (* (/ n Om) (/ (- U* U) Om)) (/ -2.0 Om)))))
(* l (sqrt 2.0)))
(sqrt (* 2.0 (* U (* n (fma t_1 -2.0 t)))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = l * (l / Om);
double tmp;
if (l <= 5.4e+57) {
tmp = sqrt(((2.0 * U) * (n * (fma(-2.0, t_1, t) + ((n / Om) * (((l * l) * U_42_) / Om))))));
} else if ((l <= 4e+151) || !(l <= 5.8e+216)) {
tmp = sqrt((U * (n * (((n / Om) * ((U_42_ - U) / Om)) + (-2.0 / Om))))) * (l * sqrt(2.0));
} else {
tmp = sqrt((2.0 * (U * (n * fma(t_1, -2.0, t)))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(l * Float64(l / Om)) tmp = 0.0 if (l <= 5.4e+57) tmp = sqrt(Float64(Float64(2.0 * U) * Float64(n * Float64(fma(-2.0, t_1, t) + Float64(Float64(n / Om) * Float64(Float64(Float64(l * l) * U_42_) / Om)))))); elseif ((l <= 4e+151) || !(l <= 5.8e+216)) tmp = Float64(sqrt(Float64(U * Float64(n * Float64(Float64(Float64(n / Om) * Float64(Float64(U_42_ - U) / Om)) + Float64(-2.0 / Om))))) * Float64(l * sqrt(2.0))); else tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(t_1, -2.0, t))))); 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]}, If[LessEqual[l, 5.4e+57], N[Sqrt[N[(N[(2.0 * U), $MachinePrecision] * N[(n * N[(N[(-2.0 * t$95$1 + t), $MachinePrecision] + N[(N[(n / Om), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * U$42$), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[Or[LessEqual[l, 4e+151], N[Not[LessEqual[l, 5.8e+216]], $MachinePrecision]], N[(N[Sqrt[N[(U * N[(n * N[(N[(N[(n / Om), $MachinePrecision] * N[(N[(U$42$ - U), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision] + N[(-2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t$95$1 * -2.0 + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \ell \cdot \frac{\ell}{Om}\\
\mathbf{if}\;\ell \leq 5.4 \cdot 10^{+57}:\\
\;\;\;\;\sqrt{\left(2 \cdot U\right) \cdot \left(n \cdot \left(\mathsf{fma}\left(-2, t_1, t\right) + \frac{n}{Om} \cdot \frac{\left(\ell \cdot \ell\right) \cdot U*}{Om}\right)\right)}\\
\mathbf{elif}\;\ell \leq 4 \cdot 10^{+151} \lor \neg \left(\ell \leq 5.8 \cdot 10^{+216}\right):\\
\;\;\;\;\sqrt{U \cdot \left(n \cdot \left(\frac{n}{Om} \cdot \frac{U* - U}{Om} + \frac{-2}{Om}\right)\right)} \cdot \left(\ell \cdot \sqrt{2}\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(t_1, -2, t\right)\right)\right)}\\
\end{array}
\end{array}
if l < 5.3999999999999997e57Initial program 50.5%
Simplified49.3%
Taylor expanded in U around 0 46.7%
associate-*r*46.7%
+-commutative46.7%
mul-1-neg46.7%
unsub-neg46.7%
associate-+l-46.7%
cancel-sign-sub-inv46.7%
metadata-eval46.7%
+-commutative46.7%
unpow246.7%
associate-*r/47.1%
fma-def47.1%
Simplified50.6%
if 5.3999999999999997e57 < l < 4.00000000000000007e151 or 5.8000000000000002e216 < l Initial program 25.1%
Simplified30.6%
Taylor expanded in l around inf 57.7%
sub-neg57.7%
unpow257.7%
times-frac71.8%
associate-*r/71.8%
metadata-eval71.8%
distribute-neg-frac71.8%
metadata-eval71.8%
Simplified71.8%
if 4.00000000000000007e151 < l < 5.8000000000000002e216Initial program 13.1%
Simplified39.2%
Taylor expanded in n around 0 13.7%
metadata-eval13.7%
cancel-sign-sub-inv13.7%
cancel-sign-sub-inv13.7%
metadata-eval13.7%
+-commutative13.7%
unpow213.7%
associate-*r/50.6%
*-commutative50.6%
fma-udef50.6%
Simplified50.6%
Final simplification53.4%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (sqrt (* U (- U* U)))) (t_2 (* l (/ l Om))))
(if (<= Om -4.6e+49)
(sqrt (* 2.0 (* U (* n (fma t_2 -2.0 t)))))
(if (<= Om -6.2e-174)
(sqrt
(*
2.0
(*
n
(*
U
(+ t (* (* l l) (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))
(if (<= Om -4e-216)
(* (/ l (/ Om (* n (sqrt 2.0)))) (- t_1))
(if (<= Om -6.2e-235)
(* (sqrt 2.0) (* t_1 (/ l (/ Om n))))
(if (<= Om -9.8e-253)
(sqrt (* 2.0 (* n (* U (* t_2 (/ U* (/ Om n)))))))
(if (<= Om -1e-266)
(* t_1 (/ (* (sqrt 2.0) (* n l)) Om))
(if (<= Om 2.8e-20)
(sqrt
(*
(* (/ -2.0 Om) (/ U Om))
(* (- U U*) (* (* n l) (* n l)))))
(sqrt
(* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l))))))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt((U * (U_42_ - U)));
double t_2 = l * (l / Om);
double tmp;
if (Om <= -4.6e+49) {
tmp = sqrt((2.0 * (U * (n * fma(t_2, -2.0, t)))));
} else if (Om <= -6.2e-174) {
tmp = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
} else if (Om <= -4e-216) {
tmp = (l / (Om / (n * sqrt(2.0)))) * -t_1;
} else if (Om <= -6.2e-235) {
tmp = sqrt(2.0) * (t_1 * (l / (Om / n)));
} else if (Om <= -9.8e-253) {
tmp = sqrt((2.0 * (n * (U * (t_2 * (U_42_ / (Om / n)))))));
} else if (Om <= -1e-266) {
tmp = t_1 * ((sqrt(2.0) * (n * l)) / Om);
} else if (Om <= 2.8e-20) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l)))));
} else {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(U * Float64(U_42_ - U))) t_2 = Float64(l * Float64(l / Om)) tmp = 0.0 if (Om <= -4.6e+49) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(t_2, -2.0, t))))); elseif (Om <= -6.2e-174) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))); elseif (Om <= -4e-216) tmp = Float64(Float64(l / Float64(Om / Float64(n * sqrt(2.0)))) * Float64(-t_1)); elseif (Om <= -6.2e-235) tmp = Float64(sqrt(2.0) * Float64(t_1 * Float64(l / Float64(Om / n)))); elseif (Om <= -9.8e-253) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t_2 * Float64(U_42_ / Float64(Om / n))))))); elseif (Om <= -1e-266) tmp = Float64(t_1 * Float64(Float64(sqrt(2.0) * Float64(n * l)) / Om)); elseif (Om <= 2.8e-20) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(U - U_42_) * Float64(Float64(n * l) * Float64(n * l))))); else tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))); 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[Sqrt[N[(U * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Om, -4.6e+49], N[Sqrt[N[(2.0 * N[(U * N[(n * N[(t$95$2 * -2.0 + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -6.2e-174], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -4e-216], N[(N[(l / N[(Om / N[(n * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * (-t$95$1)), $MachinePrecision], If[LessEqual[Om, -6.2e-235], N[(N[Sqrt[2.0], $MachinePrecision] * N[(t$95$1 * N[(l / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Om, -9.8e-253], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t$95$2 * N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -1e-266], N[(t$95$1 * N[(N[(N[Sqrt[2.0], $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision], If[LessEqual[Om, 2.8e-20], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(U - U$42$), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{U \cdot \left(U* - U\right)}\\
t_2 := \ell \cdot \frac{\ell}{Om}\\
\mathbf{if}\;Om \leq -4.6 \cdot 10^{+49}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(t_2, -2, t\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -6.2 \cdot 10^{-174}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -4 \cdot 10^{-216}:\\
\;\;\;\;\frac{\ell}{\frac{Om}{n \cdot \sqrt{2}}} \cdot \left(-t_1\right)\\
\mathbf{elif}\;Om \leq -6.2 \cdot 10^{-235}:\\
\;\;\;\;\sqrt{2} \cdot \left(t_1 \cdot \frac{\ell}{\frac{Om}{n}}\right)\\
\mathbf{elif}\;Om \leq -9.8 \cdot 10^{-253}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t_2 \cdot \frac{U*}{\frac{Om}{n}}\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -1 \cdot 10^{-266}:\\
\;\;\;\;t_1 \cdot \frac{\sqrt{2} \cdot \left(n \cdot \ell\right)}{Om}\\
\mathbf{elif}\;Om \leq 2.8 \cdot 10^{-20}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(U - U*\right) \cdot \left(\left(n \cdot \ell\right) \cdot \left(n \cdot \ell\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\end{array}
\end{array}
if Om < -4.60000000000000004e49Initial program 42.1%
Simplified54.2%
Taylor expanded in n around 0 43.7%
metadata-eval43.7%
cancel-sign-sub-inv43.7%
cancel-sign-sub-inv43.7%
metadata-eval43.7%
+-commutative43.7%
unpow243.7%
associate-*r/54.3%
*-commutative54.3%
fma-udef54.3%
Simplified54.3%
if -4.60000000000000004e49 < Om < -6.1999999999999998e-174Initial program 49.0%
Simplified44.6%
pow144.6%
Applied egg-rr44.6%
unpow144.6%
associate-*l*49.0%
fma-def49.0%
associate-*r*59.6%
fma-udef59.6%
*-commutative59.6%
associate-*r/57.4%
unpow257.4%
+-commutative57.4%
fma-def57.5%
+-commutative57.5%
unpow257.5%
associate-*r/59.6%
fma-def59.6%
Simplified59.6%
Taylor expanded in l around 0 66.3%
unpow266.3%
unpow266.3%
associate-*r/66.3%
metadata-eval66.3%
Simplified66.3%
if -6.1999999999999998e-174 < Om < -4.0000000000000002e-216Initial program 36.1%
Simplified24.8%
pow124.8%
Applied egg-rr24.8%
unpow124.8%
associate-*l*25.6%
fma-def25.6%
associate-*r*47.2%
fma-udef47.2%
*-commutative47.2%
associate-*r/47.2%
unpow247.2%
+-commutative47.2%
fma-def47.2%
+-commutative47.2%
unpow247.2%
associate-*r/47.2%
fma-def47.2%
Simplified47.2%
Taylor expanded in n around inf 14.0%
unpow214.0%
times-frac36.0%
unpow236.0%
associate-*r/46.5%
Simplified46.5%
Taylor expanded in n around -inf 44.6%
mul-1-neg44.6%
associate-/l*55.1%
Simplified55.1%
if -4.0000000000000002e-216 < Om < -6.2e-235Initial program 26.3%
Simplified26.3%
sqrt-prod26.3%
Applied egg-rr26.3%
Taylor expanded in n around inf 45.5%
associate-/l*50.2%
Simplified50.2%
if -6.2e-235 < Om < -9.7999999999999999e-253Initial program 27.2%
Simplified27.2%
pow127.2%
Applied egg-rr27.2%
unpow127.2%
associate-*l*50.8%
fma-def50.8%
associate-*r*51.2%
fma-udef51.2%
*-commutative51.2%
associate-*r/51.2%
unpow251.2%
+-commutative51.2%
fma-def51.2%
+-commutative51.2%
unpow251.2%
associate-*r/51.2%
fma-def51.2%
Simplified51.2%
Taylor expanded in n around inf 26.4%
unpow226.4%
times-frac28.0%
unpow228.0%
associate-*r/51.6%
Simplified51.6%
Taylor expanded in U* around inf 51.6%
associate-/l*51.6%
Simplified51.6%
if -9.7999999999999999e-253 < Om < -9.9999999999999998e-267Initial program 23.1%
Simplified23.1%
Taylor expanded in n around inf 78.9%
associate-*r*79.7%
Simplified79.7%
if -9.9999999999999998e-267 < Om < 2.8000000000000003e-20Initial program 44.5%
Simplified42.3%
Taylor expanded in n around inf 42.2%
associate-/l*40.3%
associate-*r/40.3%
unpow240.3%
associate-*r*40.3%
unpow240.3%
unpow240.3%
Simplified40.3%
*-un-lft-identity40.3%
associate-/r/42.1%
*-commutative42.1%
associate-*l*42.2%
Applied egg-rr42.2%
*-lft-identity42.2%
times-frac48.2%
unpow248.2%
unpow248.2%
associate-*r*48.1%
unpow248.1%
unpow248.1%
swap-sqr56.6%
Simplified56.6%
if 2.8000000000000003e-20 < Om Initial program 54.5%
Simplified52.8%
Taylor expanded in Om around inf 46.4%
unpow246.4%
associate-*r/52.4%
associate-*r*52.4%
Simplified52.4%
Final simplification56.8%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= Om -4e+46)
(sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t)))))
(if (<= Om -1.45e-183)
(sqrt
(*
2.0
(*
n
(* U (+ t (* (* l l) (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))
(if (<= Om -1.1e-266)
(* (sqrt 2.0) (* (sqrt (* U (- U* U))) (/ l (/ Om n))))
(if (<= Om 1.25e-21)
(sqrt (* (* (/ -2.0 Om) (/ U Om)) (* (- U U*) (* (* n l) (* n l)))))
(sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= -4e+46) {
tmp = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
} else if (Om <= -1.45e-183) {
tmp = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
} else if (Om <= -1.1e-266) {
tmp = sqrt(2.0) * (sqrt((U * (U_42_ - U))) * (l / (Om / n)));
} else if (Om <= 1.25e-21) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l)))));
} else {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (Om <= -4e+46) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))); elseif (Om <= -1.45e-183) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))); elseif (Om <= -1.1e-266) tmp = Float64(sqrt(2.0) * Float64(sqrt(Float64(U * Float64(U_42_ - U))) * Float64(l / Float64(Om / n)))); elseif (Om <= 1.25e-21) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(U - U_42_) * Float64(Float64(n * l) * Float64(n * l))))); else tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))); end return tmp end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[Om, -4e+46], 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], If[LessEqual[Om, -1.45e-183], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -1.1e-266], N[(N[Sqrt[2.0], $MachinePrecision] * N[(N[Sqrt[N[(U * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Om, 1.25e-21], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(U - U$42$), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -4 \cdot 10^{+46}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -1.45 \cdot 10^{-183}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -1.1 \cdot 10^{-266}:\\
\;\;\;\;\sqrt{2} \cdot \left(\sqrt{U \cdot \left(U* - U\right)} \cdot \frac{\ell}{\frac{Om}{n}}\right)\\
\mathbf{elif}\;Om \leq 1.25 \cdot 10^{-21}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(U - U*\right) \cdot \left(\left(n \cdot \ell\right) \cdot \left(n \cdot \ell\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\end{array}
\end{array}
if Om < -4e46Initial program 42.1%
Simplified54.2%
Taylor expanded in n around 0 43.7%
metadata-eval43.7%
cancel-sign-sub-inv43.7%
cancel-sign-sub-inv43.7%
metadata-eval43.7%
+-commutative43.7%
unpow243.7%
associate-*r/54.3%
*-commutative54.3%
fma-udef54.3%
Simplified54.3%
if -4e46 < Om < -1.45e-183Initial program 50.1%
Simplified44.0%
pow144.0%
Applied egg-rr44.0%
unpow144.0%
associate-*l*48.2%
fma-def48.2%
associate-*r*60.1%
fma-udef60.1%
*-commutative60.1%
associate-*r/58.1%
unpow258.1%
+-commutative58.1%
fma-def58.1%
+-commutative58.1%
unpow258.1%
associate-*r/60.1%
fma-def60.1%
Simplified60.1%
Taylor expanded in l around 0 64.4%
unpow264.4%
unpow264.4%
associate-*r/64.4%
metadata-eval64.4%
Simplified64.4%
if -1.45e-183 < Om < -1.1e-266Initial program 23.7%
Simplified23.5%
sqrt-prod23.6%
Applied egg-rr23.6%
Taylor expanded in n around inf 41.9%
associate-/l*43.0%
Simplified43.0%
if -1.1e-266 < Om < 1.24999999999999993e-21Initial program 44.5%
Simplified42.3%
Taylor expanded in n around inf 42.2%
associate-/l*40.3%
associate-*r/40.3%
unpow240.3%
associate-*r*40.3%
unpow240.3%
unpow240.3%
Simplified40.3%
*-un-lft-identity40.3%
associate-/r/42.1%
*-commutative42.1%
associate-*l*42.2%
Applied egg-rr42.2%
*-lft-identity42.2%
times-frac48.2%
unpow248.2%
unpow248.2%
associate-*r*48.1%
unpow248.1%
unpow248.1%
swap-sqr56.6%
Simplified56.6%
if 1.24999999999999993e-21 < Om Initial program 54.5%
Simplified52.8%
Taylor expanded in Om around inf 46.4%
unpow246.4%
associate-*r/52.4%
associate-*r*52.4%
Simplified52.4%
Final simplification55.3%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= Om -7.7e+49)
(sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t)))))
(if (<= Om -4.2e-180)
(sqrt
(*
2.0
(*
n
(* U (+ t (* (* l l) (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))
(if (<= Om -1.1e-266)
(* (sqrt (* U (- U* U))) (/ (* (sqrt 2.0) (* n l)) Om))
(if (<= Om 3.4e-21)
(sqrt (* (* (/ -2.0 Om) (/ U Om)) (* (- U U*) (* (* n l) (* n l)))))
(sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= -7.7e+49) {
tmp = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
} else if (Om <= -4.2e-180) {
tmp = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
} else if (Om <= -1.1e-266) {
tmp = sqrt((U * (U_42_ - U))) * ((sqrt(2.0) * (n * l)) / Om);
} else if (Om <= 3.4e-21) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l)))));
} else {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (Om <= -7.7e+49) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))); elseif (Om <= -4.2e-180) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))); elseif (Om <= -1.1e-266) tmp = Float64(sqrt(Float64(U * Float64(U_42_ - U))) * Float64(Float64(sqrt(2.0) * Float64(n * l)) / Om)); elseif (Om <= 3.4e-21) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(U - U_42_) * Float64(Float64(n * l) * Float64(n * l))))); else tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))); end return tmp end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[Om, -7.7e+49], 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], If[LessEqual[Om, -4.2e-180], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -1.1e-266], N[(N[Sqrt[N[(U * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(N[Sqrt[2.0], $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision], If[LessEqual[Om, 3.4e-21], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(U - U$42$), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -7.7 \cdot 10^{+49}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -4.2 \cdot 10^{-180}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -1.1 \cdot 10^{-266}:\\
\;\;\;\;\sqrt{U \cdot \left(U* - U\right)} \cdot \frac{\sqrt{2} \cdot \left(n \cdot \ell\right)}{Om}\\
\mathbf{elif}\;Om \leq 3.4 \cdot 10^{-21}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(U - U*\right) \cdot \left(\left(n \cdot \ell\right) \cdot \left(n \cdot \ell\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\end{array}
\end{array}
if Om < -7.7e49Initial program 42.1%
Simplified54.2%
Taylor expanded in n around 0 43.7%
metadata-eval43.7%
cancel-sign-sub-inv43.7%
cancel-sign-sub-inv43.7%
metadata-eval43.7%
+-commutative43.7%
unpow243.7%
associate-*r/54.3%
*-commutative54.3%
fma-udef54.3%
Simplified54.3%
if -7.7e49 < Om < -4.1999999999999997e-180Initial program 50.1%
Simplified44.0%
pow144.0%
Applied egg-rr44.0%
unpow144.0%
associate-*l*48.2%
fma-def48.2%
associate-*r*60.1%
fma-udef60.1%
*-commutative60.1%
associate-*r/58.1%
unpow258.1%
+-commutative58.1%
fma-def58.1%
+-commutative58.1%
unpow258.1%
associate-*r/60.1%
fma-def60.1%
Simplified60.1%
Taylor expanded in l around 0 64.4%
unpow264.4%
unpow264.4%
associate-*r/64.4%
metadata-eval64.4%
Simplified64.4%
if -4.1999999999999997e-180 < Om < -1.1e-266Initial program 23.7%
Simplified23.5%
Taylor expanded in n around inf 41.8%
associate-*r*41.9%
Simplified41.9%
if -1.1e-266 < Om < 3.4e-21Initial program 44.5%
Simplified42.3%
Taylor expanded in n around inf 42.2%
associate-/l*40.3%
associate-*r/40.3%
unpow240.3%
associate-*r*40.3%
unpow240.3%
unpow240.3%
Simplified40.3%
*-un-lft-identity40.3%
associate-/r/42.1%
*-commutative42.1%
associate-*l*42.2%
Applied egg-rr42.2%
*-lft-identity42.2%
times-frac48.2%
unpow248.2%
unpow248.2%
associate-*r*48.1%
unpow248.1%
unpow248.1%
swap-sqr56.6%
Simplified56.6%
if 3.4e-21 < Om Initial program 54.5%
Simplified52.8%
Taylor expanded in Om around inf 46.4%
unpow246.4%
associate-*r/52.4%
associate-*r*52.4%
Simplified52.4%
Final simplification55.3%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= Om -9.2e+45)
(sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t)))))
(if (<= Om -1.4e-180)
(sqrt
(*
2.0
(*
n
(* U (+ t (* (* l l) (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))
(if (<= Om -1.1e-266)
(/ (* (sqrt (* U (- U* U))) (* l (* n (sqrt 2.0)))) Om)
(if (<= Om 4.2e-22)
(sqrt (* (* (/ -2.0 Om) (/ U Om)) (* (- U U*) (* (* n l) (* n l)))))
(sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (Om <= -9.2e+45) {
tmp = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
} else if (Om <= -1.4e-180) {
tmp = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
} else if (Om <= -1.1e-266) {
tmp = (sqrt((U * (U_42_ - U))) * (l * (n * sqrt(2.0)))) / Om;
} else if (Om <= 4.2e-22) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l)))));
} else {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (Om <= -9.2e+45) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))); elseif (Om <= -1.4e-180) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))); elseif (Om <= -1.1e-266) tmp = Float64(Float64(sqrt(Float64(U * Float64(U_42_ - U))) * Float64(l * Float64(n * sqrt(2.0)))) / Om); elseif (Om <= 4.2e-22) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(U - U_42_) * Float64(Float64(n * l) * Float64(n * l))))); else tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))); end return tmp end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[Om, -9.2e+45], 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], If[LessEqual[Om, -1.4e-180], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -1.1e-266], N[(N[(N[Sqrt[N[(U * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(l * N[(n * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision], If[LessEqual[Om, 4.2e-22], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(U - U$42$), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -9.2 \cdot 10^{+45}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -1.4 \cdot 10^{-180}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -1.1 \cdot 10^{-266}:\\
\;\;\;\;\frac{\sqrt{U \cdot \left(U* - U\right)} \cdot \left(\ell \cdot \left(n \cdot \sqrt{2}\right)\right)}{Om}\\
\mathbf{elif}\;Om \leq 4.2 \cdot 10^{-22}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(U - U*\right) \cdot \left(\left(n \cdot \ell\right) \cdot \left(n \cdot \ell\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\end{array}
\end{array}
if Om < -9.20000000000000049e45Initial program 42.1%
Simplified54.2%
Taylor expanded in n around 0 43.7%
metadata-eval43.7%
cancel-sign-sub-inv43.7%
cancel-sign-sub-inv43.7%
metadata-eval43.7%
+-commutative43.7%
unpow243.7%
associate-*r/54.3%
*-commutative54.3%
fma-udef54.3%
Simplified54.3%
if -9.20000000000000049e45 < Om < -1.39999999999999999e-180Initial program 50.1%
Simplified44.0%
pow144.0%
Applied egg-rr44.0%
unpow144.0%
associate-*l*48.2%
fma-def48.2%
associate-*r*60.1%
fma-udef60.1%
*-commutative60.1%
associate-*r/58.1%
unpow258.1%
+-commutative58.1%
fma-def58.1%
+-commutative58.1%
unpow258.1%
associate-*r/60.1%
fma-def60.1%
Simplified60.1%
Taylor expanded in l around 0 64.4%
unpow264.4%
unpow264.4%
associate-*r/64.4%
metadata-eval64.4%
Simplified64.4%
if -1.39999999999999999e-180 < Om < -1.1e-266Initial program 23.7%
Simplified23.5%
Taylor expanded in n around inf 41.8%
associate-*l/42.0%
Simplified42.0%
if -1.1e-266 < Om < 4.20000000000000016e-22Initial program 44.5%
Simplified42.3%
Taylor expanded in n around inf 42.2%
associate-/l*40.3%
associate-*r/40.3%
unpow240.3%
associate-*r*40.3%
unpow240.3%
unpow240.3%
Simplified40.3%
*-un-lft-identity40.3%
associate-/r/42.1%
*-commutative42.1%
associate-*l*42.2%
Applied egg-rr42.2%
*-lft-identity42.2%
times-frac48.2%
unpow248.2%
unpow248.2%
associate-*r*48.1%
unpow248.1%
unpow248.1%
swap-sqr56.6%
Simplified56.6%
if 4.20000000000000016e-22 < Om Initial program 54.5%
Simplified52.8%
Taylor expanded in Om around inf 46.4%
unpow246.4%
associate-*r/52.4%
associate-*r*52.4%
Simplified52.4%
Final simplification55.3%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1
(sqrt
(*
2.0
(*
n
(*
U
(+
t
(* (* l l) (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))))
(if (<= Om -7.7e+49)
(sqrt (* 2.0 (* U (* n (fma (* l (/ l Om)) -2.0 t)))))
(if (<= Om -6.4e-131)
t_1
(if (<= Om 2.1e-55)
(sqrt (* (* (/ -2.0 Om) (/ U Om)) (* (- U U*) (* (* n l) (* n l)))))
(if (<= Om 100.0)
t_1
(sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l)))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
double tmp;
if (Om <= -7.7e+49) {
tmp = sqrt((2.0 * (U * (n * fma((l * (l / Om)), -2.0, t)))));
} else if (Om <= -6.4e-131) {
tmp = t_1;
} else if (Om <= 2.1e-55) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l)))));
} else if (Om <= 100.0) {
tmp = t_1;
} else {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
}
return tmp;
}
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))) tmp = 0.0 if (Om <= -7.7e+49) tmp = sqrt(Float64(2.0 * Float64(U * Float64(n * fma(Float64(l * Float64(l / Om)), -2.0, t))))); elseif (Om <= -6.4e-131) tmp = t_1; elseif (Om <= 2.1e-55) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(U - U_42_) * Float64(Float64(n * l) * Float64(n * l))))); elseif (Om <= 100.0) tmp = t_1; else tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))); 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[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[Om, -7.7e+49], 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], If[LessEqual[Om, -6.4e-131], t$95$1, If[LessEqual[Om, 2.1e-55], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(U - U$42$), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, 100.0], t$95$1, N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{if}\;Om \leq -7.7 \cdot 10^{+49}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(n \cdot \mathsf{fma}\left(\ell \cdot \frac{\ell}{Om}, -2, t\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -6.4 \cdot 10^{-131}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Om \leq 2.1 \cdot 10^{-55}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(U - U*\right) \cdot \left(\left(n \cdot \ell\right) \cdot \left(n \cdot \ell\right)\right)\right)}\\
\mathbf{elif}\;Om \leq 100:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\end{array}
\end{array}
if Om < -7.7e49Initial program 42.1%
Simplified54.2%
Taylor expanded in n around 0 43.7%
metadata-eval43.7%
cancel-sign-sub-inv43.7%
cancel-sign-sub-inv43.7%
metadata-eval43.7%
+-commutative43.7%
unpow243.7%
associate-*r/54.3%
*-commutative54.3%
fma-udef54.3%
Simplified54.3%
if -7.7e49 < Om < -6.3999999999999999e-131 or 2.1000000000000002e-55 < Om < 100Initial program 50.9%
Simplified45.2%
pow145.2%
Applied egg-rr45.2%
unpow145.2%
associate-*l*51.2%
fma-def51.2%
associate-*r*61.9%
fma-udef61.9%
*-commutative61.9%
associate-*r/60.1%
unpow260.1%
+-commutative60.1%
fma-def60.2%
+-commutative60.2%
unpow260.2%
associate-*r/62.0%
fma-def62.0%
Simplified62.0%
Taylor expanded in l around 0 71.4%
unpow271.4%
unpow271.4%
associate-*r/71.4%
metadata-eval71.4%
Simplified71.4%
if -6.3999999999999999e-131 < Om < 2.1000000000000002e-55Initial program 39.2%
Simplified37.6%
Taylor expanded in n around inf 32.6%
associate-/l*31.3%
associate-*r/31.3%
unpow231.3%
associate-*r*31.3%
unpow231.3%
unpow231.3%
Simplified31.3%
*-un-lft-identity31.3%
associate-/r/32.5%
*-commutative32.5%
associate-*l*32.6%
Applied egg-rr32.6%
*-lft-identity32.6%
times-frac39.7%
unpow239.7%
unpow239.7%
associate-*r*38.3%
unpow238.3%
unpow238.3%
swap-sqr44.6%
Simplified44.6%
if 100 < Om Initial program 54.2%
Simplified52.3%
Taylor expanded in Om around inf 46.6%
unpow246.6%
associate-*r/53.2%
associate-*r*53.2%
Simplified53.2%
Final simplification55.0%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l))))))
(t_2
(sqrt
(*
2.0
(*
n
(*
U
(+
t
(* (* l l) (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om))))))))))
(if (<= Om -3.1e+48)
t_1
(if (<= Om -4.4e-130)
t_2
(if (<= Om 1.12e-54)
(sqrt (* (* (/ -2.0 Om) (/ U Om)) (* (- U U*) (* (* n l) (* n l)))))
(if (<= Om 115.0) t_2 t_1))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
double t_2 = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
double tmp;
if (Om <= -3.1e+48) {
tmp = t_1;
} else if (Om <= -4.4e-130) {
tmp = t_2;
} else if (Om <= 1.12e-54) {
tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l)))));
} else if (Om <= 115.0) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = sqrt(((2.0d0 * (n * u)) * (t - ((l / om) * (2.0d0 * l)))))
t_2 = sqrt((2.0d0 * (n * (u * (t + ((l * l) * (((n * (u_42 - u)) / (om * om)) - (2.0d0 / om))))))))
if (om <= (-3.1d+48)) then
tmp = t_1
else if (om <= (-4.4d-130)) then
tmp = t_2
else if (om <= 1.12d-54) then
tmp = sqrt(((((-2.0d0) / om) * (u / om)) * ((u - u_42) * ((n * l) * (n * l)))))
else if (om <= 115.0d0) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
double t_2 = Math.sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))));
double tmp;
if (Om <= -3.1e+48) {
tmp = t_1;
} else if (Om <= -4.4e-130) {
tmp = t_2;
} else if (Om <= 1.12e-54) {
tmp = Math.sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l)))));
} else if (Om <= 115.0) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))) t_2 = math.sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om)))))))) tmp = 0 if Om <= -3.1e+48: tmp = t_1 elif Om <= -4.4e-130: tmp = t_2 elif Om <= 1.12e-54: tmp = math.sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l))))) elif Om <= 115.0: tmp = t_2 else: tmp = t_1 return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))) t_2 = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(t + Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om)))))))) tmp = 0.0 if (Om <= -3.1e+48) tmp = t_1; elseif (Om <= -4.4e-130) tmp = t_2; elseif (Om <= 1.12e-54) tmp = sqrt(Float64(Float64(Float64(-2.0 / Om) * Float64(U / Om)) * Float64(Float64(U - U_42_) * Float64(Float64(n * l) * Float64(n * l))))); elseif (Om <= 115.0) tmp = t_2; else tmp = t_1; end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))); t_2 = sqrt((2.0 * (n * (U * (t + ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om)))))))); tmp = 0.0; if (Om <= -3.1e+48) tmp = t_1; elseif (Om <= -4.4e-130) tmp = t_2; elseif (Om <= 1.12e-54) tmp = sqrt((((-2.0 / Om) * (U / Om)) * ((U - U_42_) * ((n * l) * (n * l))))); elseif (Om <= 115.0) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(2.0 * N[(n * N[(U * N[(t + N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[Om, -3.1e+48], t$95$1, If[LessEqual[Om, -4.4e-130], t$95$2, If[LessEqual[Om, 1.12e-54], N[Sqrt[N[(N[(N[(-2.0 / Om), $MachinePrecision] * N[(U / Om), $MachinePrecision]), $MachinePrecision] * N[(N[(U - U$42$), $MachinePrecision] * N[(N[(n * l), $MachinePrecision] * N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, 115.0], t$95$2, t$95$1]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
t_2 := \sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(t + \left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{if}\;Om \leq -3.1 \cdot 10^{+48}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Om \leq -4.4 \cdot 10^{-130}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;Om \leq 1.12 \cdot 10^{-54}:\\
\;\;\;\;\sqrt{\left(\frac{-2}{Om} \cdot \frac{U}{Om}\right) \cdot \left(\left(U - U*\right) \cdot \left(\left(n \cdot \ell\right) \cdot \left(n \cdot \ell\right)\right)\right)}\\
\mathbf{elif}\;Om \leq 115:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if Om < -3.10000000000000005e48 or 115 < Om Initial program 47.5%
Simplified49.4%
Taylor expanded in Om around inf 44.2%
unpow244.2%
associate-*r/53.1%
associate-*r*53.1%
Simplified53.1%
if -3.10000000000000005e48 < Om < -4.3999999999999997e-130 or 1.11999999999999994e-54 < Om < 115Initial program 50.9%
Simplified45.2%
pow145.2%
Applied egg-rr45.2%
unpow145.2%
associate-*l*51.2%
fma-def51.2%
associate-*r*61.9%
fma-udef61.9%
*-commutative61.9%
associate-*r/60.1%
unpow260.1%
+-commutative60.1%
fma-def60.2%
+-commutative60.2%
unpow260.2%
associate-*r/62.0%
fma-def62.0%
Simplified62.0%
Taylor expanded in l around 0 71.4%
unpow271.4%
unpow271.4%
associate-*r/71.4%
metadata-eval71.4%
Simplified71.4%
if -4.3999999999999997e-130 < Om < 1.11999999999999994e-54Initial program 39.2%
Simplified37.6%
Taylor expanded in n around inf 32.6%
associate-/l*31.3%
associate-*r/31.3%
unpow231.3%
associate-*r*31.3%
unpow231.3%
unpow231.3%
Simplified31.3%
*-un-lft-identity31.3%
associate-/r/32.5%
*-commutative32.5%
associate-*l*32.6%
Applied egg-rr32.6%
*-lft-identity32.6%
times-frac39.7%
unpow239.7%
unpow239.7%
associate-*r*38.3%
unpow238.3%
unpow238.3%
swap-sqr44.6%
Simplified44.6%
Final simplification54.6%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l)))))))
(if (<= Om -2e+42)
t_1
(if (<= Om -1.65e-65)
(sqrt
(*
2.0
(* U (* (* l l) (* n (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om)))))))
(if (<= Om -4.8e-172)
(pow (* 2.0 (* U (* n t))) 0.5)
(if (<= Om 2.95e-173)
(sqrt (* 2.0 (* n (* U (* (* l (/ l Om)) (/ U* (/ Om n)))))))
t_1))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
double tmp;
if (Om <= -2e+42) {
tmp = t_1;
} else if (Om <= -1.65e-65) {
tmp = sqrt((2.0 * (U * ((l * l) * (n * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om)))))));
} else if (Om <= -4.8e-172) {
tmp = pow((2.0 * (U * (n * t))), 0.5);
} else if (Om <= 2.95e-173) {
tmp = sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n)))))));
} else {
tmp = t_1;
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt(((2.0d0 * (n * u)) * (t - ((l / om) * (2.0d0 * l)))))
if (om <= (-2d+42)) then
tmp = t_1
else if (om <= (-1.65d-65)) then
tmp = sqrt((2.0d0 * (u * ((l * l) * (n * (((n * (u_42 - u)) / (om * om)) - (2.0d0 / om)))))))
else if (om <= (-4.8d-172)) then
tmp = (2.0d0 * (u * (n * t))) ** 0.5d0
else if (om <= 2.95d-173) then
tmp = sqrt((2.0d0 * (n * (u * ((l * (l / om)) * (u_42 / (om / n)))))))
else
tmp = t_1
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
double tmp;
if (Om <= -2e+42) {
tmp = t_1;
} else if (Om <= -1.65e-65) {
tmp = Math.sqrt((2.0 * (U * ((l * l) * (n * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om)))))));
} else if (Om <= -4.8e-172) {
tmp = Math.pow((2.0 * (U * (n * t))), 0.5);
} else if (Om <= 2.95e-173) {
tmp = Math.sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n)))))));
} else {
tmp = t_1;
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))) tmp = 0 if Om <= -2e+42: tmp = t_1 elif Om <= -1.65e-65: tmp = math.sqrt((2.0 * (U * ((l * l) * (n * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))) elif Om <= -4.8e-172: tmp = math.pow((2.0 * (U * (n * t))), 0.5) elif Om <= 2.95e-173: tmp = math.sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n))))))) else: tmp = t_1 return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))) tmp = 0.0 if (Om <= -2e+42) tmp = t_1; elseif (Om <= -1.65e-65) tmp = sqrt(Float64(2.0 * Float64(U * Float64(Float64(l * l) * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om))))))); elseif (Om <= -4.8e-172) tmp = Float64(2.0 * Float64(U * Float64(n * t))) ^ 0.5; elseif (Om <= 2.95e-173) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(Float64(l * Float64(l / Om)) * Float64(U_42_ / Float64(Om / n))))))); else tmp = t_1; end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))); tmp = 0.0; if (Om <= -2e+42) tmp = t_1; elseif (Om <= -1.65e-65) tmp = sqrt((2.0 * (U * ((l * l) * (n * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))); elseif (Om <= -4.8e-172) tmp = (2.0 * (U * (n * t))) ^ 0.5; elseif (Om <= 2.95e-173) tmp = sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n))))))); else tmp = t_1; end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[Om, -2e+42], t$95$1, If[LessEqual[Om, -1.65e-65], N[Sqrt[N[(2.0 * N[(U * N[(N[(l * l), $MachinePrecision] * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -4.8e-172], N[Power[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], If[LessEqual[Om, 2.95e-173], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\mathbf{if}\;Om \leq -2 \cdot 10^{+42}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Om \leq -1.65 \cdot 10^{-65}:\\
\;\;\;\;\sqrt{2 \cdot \left(U \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -4.8 \cdot 10^{-172}:\\
\;\;\;\;{\left(2 \cdot \left(U \cdot \left(n \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{elif}\;Om \leq 2.95 \cdot 10^{-173}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(\left(\ell \cdot \frac{\ell}{Om}\right) \cdot \frac{U*}{\frac{Om}{n}}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if Om < -2.00000000000000009e42 or 2.94999999999999998e-173 < Om Initial program 49.2%
Simplified50.1%
Taylor expanded in Om around inf 44.8%
unpow244.8%
associate-*r/51.9%
associate-*r*51.9%
Simplified51.9%
if -2.00000000000000009e42 < Om < -1.6500000000000001e-65Initial program 26.1%
Simplified25.6%
Taylor expanded in l around inf 44.6%
unpow244.6%
unpow244.6%
associate-*r/44.6%
metadata-eval44.6%
Simplified44.6%
if -1.6500000000000001e-65 < Om < -4.8000000000000002e-172Initial program 66.9%
Simplified66.9%
Taylor expanded in t around inf 45.8%
associate-*r*45.8%
Simplified45.8%
pow1/258.3%
associate-*l*58.3%
Applied egg-rr58.3%
if -4.8000000000000002e-172 < Om < 2.94999999999999998e-173Initial program 31.7%
Simplified27.2%
pow127.2%
Applied egg-rr27.2%
unpow127.2%
associate-*l*29.8%
fma-def29.8%
associate-*r*34.3%
fma-udef34.3%
*-commutative34.3%
associate-*r/34.3%
unpow234.3%
+-commutative34.3%
fma-def34.3%
+-commutative34.3%
unpow234.3%
associate-*r/34.3%
fma-def34.3%
Simplified34.3%
Taylor expanded in n around inf 36.1%
unpow236.1%
times-frac40.9%
unpow240.9%
associate-*r/45.6%
Simplified45.6%
Taylor expanded in U* around inf 45.7%
associate-/l*45.8%
Simplified45.8%
Final simplification50.8%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l)))))))
(if (<= Om -2.5e+42)
t_1
(if (<= Om -3.7e-69)
(sqrt
(*
2.0
(* n (* U (* (* l l) (- (/ (* n (- U* U)) (* Om Om)) (/ 2.0 Om)))))))
(if (<= Om -7e-173)
(pow (* 2.0 (* U (* n t))) 0.5)
(if (<= Om 8e-173)
(sqrt (* 2.0 (* n (* U (* (* l (/ l Om)) (/ U* (/ Om n)))))))
t_1))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
double tmp;
if (Om <= -2.5e+42) {
tmp = t_1;
} else if (Om <= -3.7e-69) {
tmp = sqrt((2.0 * (n * (U * ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om)))))));
} else if (Om <= -7e-173) {
tmp = pow((2.0 * (U * (n * t))), 0.5);
} else if (Om <= 8e-173) {
tmp = sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n)))))));
} else {
tmp = t_1;
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt(((2.0d0 * (n * u)) * (t - ((l / om) * (2.0d0 * l)))))
if (om <= (-2.5d+42)) then
tmp = t_1
else if (om <= (-3.7d-69)) then
tmp = sqrt((2.0d0 * (n * (u * ((l * l) * (((n * (u_42 - u)) / (om * om)) - (2.0d0 / om)))))))
else if (om <= (-7d-173)) then
tmp = (2.0d0 * (u * (n * t))) ** 0.5d0
else if (om <= 8d-173) then
tmp = sqrt((2.0d0 * (n * (u * ((l * (l / om)) * (u_42 / (om / n)))))))
else
tmp = t_1
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = Math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
double tmp;
if (Om <= -2.5e+42) {
tmp = t_1;
} else if (Om <= -3.7e-69) {
tmp = Math.sqrt((2.0 * (n * (U * ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om)))))));
} else if (Om <= -7e-173) {
tmp = Math.pow((2.0 * (U * (n * t))), 0.5);
} else if (Om <= 8e-173) {
tmp = Math.sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n)))))));
} else {
tmp = t_1;
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))) tmp = 0 if Om <= -2.5e+42: tmp = t_1 elif Om <= -3.7e-69: tmp = math.sqrt((2.0 * (n * (U * ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))) elif Om <= -7e-173: tmp = math.pow((2.0 * (U * (n * t))), 0.5) elif Om <= 8e-173: tmp = math.sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n))))))) else: tmp = t_1 return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))) tmp = 0.0 if (Om <= -2.5e+42) tmp = t_1; elseif (Om <= -3.7e-69) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(Float64(l * l) * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Float64(Om * Om)) - Float64(2.0 / Om))))))); elseif (Om <= -7e-173) tmp = Float64(2.0 * Float64(U * Float64(n * t))) ^ 0.5; elseif (Om <= 8e-173) tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(Float64(l * Float64(l / Om)) * Float64(U_42_ / Float64(Om / n))))))); else tmp = t_1; end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))); tmp = 0.0; if (Om <= -2.5e+42) tmp = t_1; elseif (Om <= -3.7e-69) tmp = sqrt((2.0 * (n * (U * ((l * l) * (((n * (U_42_ - U)) / (Om * Om)) - (2.0 / Om))))))); elseif (Om <= -7e-173) tmp = (2.0 * (U * (n * t))) ^ 0.5; elseif (Om <= 8e-173) tmp = sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n))))))); else tmp = t_1; end tmp_2 = tmp; end
NOTE: l should be positive before calling this function
code[n_, U_, t_, l_, Om_, U$42$_] := Block[{t$95$1 = N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[Om, -2.5e+42], t$95$1, If[LessEqual[Om, -3.7e-69], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(N[(l * l), $MachinePrecision] * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / N[(Om * Om), $MachinePrecision]), $MachinePrecision] - N[(2.0 / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[Om, -7e-173], N[Power[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], If[LessEqual[Om, 8e-173], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\mathbf{if}\;Om \leq -2.5 \cdot 10^{+42}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;Om \leq -3.7 \cdot 10^{-69}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om \cdot Om} - \frac{2}{Om}\right)\right)\right)\right)}\\
\mathbf{elif}\;Om \leq -7 \cdot 10^{-173}:\\
\;\;\;\;{\left(2 \cdot \left(U \cdot \left(n \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{elif}\;Om \leq 8 \cdot 10^{-173}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(\left(\ell \cdot \frac{\ell}{Om}\right) \cdot \frac{U*}{\frac{Om}{n}}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if Om < -2.50000000000000003e42 or 8.0000000000000003e-173 < Om Initial program 49.2%
Simplified50.1%
Taylor expanded in Om around inf 44.8%
unpow244.8%
associate-*r/51.9%
associate-*r*51.9%
Simplified51.9%
if -2.50000000000000003e42 < Om < -3.7000000000000002e-69Initial program 26.1%
Simplified25.6%
pow125.6%
Applied egg-rr25.6%
unpow125.6%
associate-*l*35.2%
fma-def35.2%
associate-*r*49.0%
fma-udef49.0%
*-commutative49.0%
associate-*r/44.4%
unpow244.4%
+-commutative44.4%
fma-def44.5%
+-commutative44.5%
unpow244.5%
associate-*r/49.1%
fma-def49.1%
Simplified49.1%
Taylor expanded in l around inf 44.8%
unpow244.8%
unpow244.8%
associate-*r/44.8%
metadata-eval44.8%
Simplified44.8%
if -3.7000000000000002e-69 < Om < -7.00000000000000029e-173Initial program 66.9%
Simplified66.9%
Taylor expanded in t around inf 45.8%
associate-*r*45.8%
Simplified45.8%
pow1/258.3%
associate-*l*58.3%
Applied egg-rr58.3%
if -7.00000000000000029e-173 < Om < 8.0000000000000003e-173Initial program 31.7%
Simplified27.2%
pow127.2%
Applied egg-rr27.2%
unpow127.2%
associate-*l*29.8%
fma-def29.8%
associate-*r*34.3%
fma-udef34.3%
*-commutative34.3%
associate-*r/34.3%
unpow234.3%
+-commutative34.3%
fma-def34.3%
+-commutative34.3%
unpow234.3%
associate-*r/34.3%
fma-def34.3%
Simplified34.3%
Taylor expanded in n around inf 36.1%
unpow236.1%
times-frac40.9%
unpow240.9%
associate-*r/45.6%
Simplified45.6%
Taylor expanded in U* around inf 45.7%
associate-/l*45.8%
Simplified45.8%
Final simplification50.9%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (or (<= Om -1.3e-123) (not (<= Om 6.6e-173))) (sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l))))) (sqrt (* 2.0 (* n (* U (* (* l (/ l Om)) (/ U* (/ Om n)))))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if ((Om <= -1.3e-123) || !(Om <= 6.6e-173)) {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
} else {
tmp = sqrt((2.0 * (n * (U * ((l * (l / Om)) * (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 ((om <= (-1.3d-123)) .or. (.not. (om <= 6.6d-173))) then
tmp = sqrt(((2.0d0 * (n * u)) * (t - ((l / om) * (2.0d0 * l)))))
else
tmp = sqrt((2.0d0 * (n * (u * ((l * (l / om)) * (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 ((Om <= -1.3e-123) || !(Om <= 6.6e-173)) {
tmp = Math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
} else {
tmp = Math.sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n)))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if (Om <= -1.3e-123) or not (Om <= 6.6e-173): tmp = math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))) else: tmp = math.sqrt((2.0 * (n * (U * ((l * (l / Om)) * (U_42_ / (Om / n))))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if ((Om <= -1.3e-123) || !(Om <= 6.6e-173)) tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))); else tmp = sqrt(Float64(2.0 * Float64(n * Float64(U * Float64(Float64(l * Float64(l / Om)) * 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 ((Om <= -1.3e-123) || ~((Om <= 6.6e-173))) tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))); else tmp = sqrt((2.0 * (n * (U * ((l * (l / Om)) * (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[Or[LessEqual[Om, -1.3e-123], N[Not[LessEqual[Om, 6.6e-173]], $MachinePrecision]], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(n * N[(U * N[(N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision] * N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;Om \leq -1.3 \cdot 10^{-123} \lor \neg \left(Om \leq 6.6 \cdot 10^{-173}\right):\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(n \cdot \left(U \cdot \left(\left(\ell \cdot \frac{\ell}{Om}\right) \cdot \frac{U*}{\frac{Om}{n}}\right)\right)\right)}\\
\end{array}
\end{array}
if Om < -1.29999999999999998e-123 or 6.6000000000000006e-173 < Om Initial program 48.6%
Simplified49.3%
Taylor expanded in Om around inf 43.7%
unpow243.7%
associate-*r/49.5%
associate-*r*49.5%
Simplified49.5%
if -1.29999999999999998e-123 < Om < 6.6000000000000006e-173Initial program 35.2%
Simplified31.4%
pow131.4%
Applied egg-rr31.4%
unpow131.4%
associate-*l*35.5%
fma-def35.5%
associate-*r*39.3%
fma-udef39.3%
*-commutative39.3%
associate-*r/39.3%
unpow239.3%
+-commutative39.3%
fma-def39.3%
+-commutative39.3%
unpow239.3%
associate-*r/39.3%
fma-def39.3%
Simplified39.3%
Taylor expanded in n around inf 37.2%
unpow237.2%
times-frac41.5%
unpow241.5%
associate-*r/45.5%
Simplified45.5%
Taylor expanded in U* around inf 45.7%
associate-/l*45.8%
Simplified45.8%
Final simplification48.8%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= U* -2.5e+143) (pow (* 2.0 (* U (* n t))) 0.5) (sqrt (* (* 2.0 (* n U)) (- t (* (/ l Om) (* 2.0 l)))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U_42_ <= -2.5e+143) {
tmp = pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (u_42 <= (-2.5d+143)) then
tmp = (2.0d0 * (u * (n * t))) ** 0.5d0
else
tmp = sqrt(((2.0d0 * (n * u)) * (t - ((l / om) * (2.0d0 * l)))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U_42_ <= -2.5e+143) {
tmp = Math.pow((2.0 * (U * (n * t))), 0.5);
} else {
tmp = Math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l)))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if U_42_ <= -2.5e+143: tmp = math.pow((2.0 * (U * (n * t))), 0.5) else: tmp = math.sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U_42_ <= -2.5e+143) tmp = Float64(2.0 * Float64(U * Float64(n * t))) ^ 0.5; else tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(t - Float64(Float64(l / Om) * Float64(2.0 * l))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U_42_ <= -2.5e+143) tmp = (2.0 * (U * (n * t))) ^ 0.5; else tmp = sqrt(((2.0 * (n * U)) * (t - ((l / Om) * (2.0 * l))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U$42$, -2.5e+143], N[Power[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(t - N[(N[(l / Om), $MachinePrecision] * N[(2.0 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U* \leq -2.5 \cdot 10^{+143}:\\
\;\;\;\;{\left(2 \cdot \left(U \cdot \left(n \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(t - \frac{\ell}{Om} \cdot \left(2 \cdot \ell\right)\right)}\\
\end{array}
\end{array}
if U* < -2.50000000000000006e143Initial program 34.9%
Simplified31.0%
Taylor expanded in t around inf 25.6%
associate-*r*25.6%
Simplified25.6%
pow1/231.4%
associate-*l*31.4%
Applied egg-rr31.4%
if -2.50000000000000006e143 < U* Initial program 48.8%
Simplified50.4%
Taylor expanded in Om around inf 44.2%
unpow244.2%
associate-*r/49.0%
associate-*r*49.0%
Simplified49.0%
Final simplification45.4%
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 45.9%
Simplified46.5%
Taylor expanded in t around inf 34.4%
associate-*r*34.4%
Simplified34.4%
pow1/235.9%
associate-*l*35.9%
Applied egg-rr35.9%
Final simplification35.9%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (sqrt (* 2.0 (* t (* n U)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((2.0 * (t * (n * U))));
}
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 * (t * (n * u))))
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 * (t * (n * U))));
}
l = abs(l) def code(n, U, t, l, Om, U_42_): return math.sqrt((2.0 * (t * (n * U))))
l = abs(l) function code(n, U, t, l, Om, U_42_) return sqrt(Float64(2.0 * Float64(t * Float64(n * U)))) end
l = abs(l) function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((2.0 * (t * (n * U)))); end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(2.0 * N[(t * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
\sqrt{2 \cdot \left(t \cdot \left(n \cdot U\right)\right)}
\end{array}
Initial program 45.9%
Simplified47.8%
Taylor expanded in l around 0 34.4%
associate-*r*33.7%
*-commutative33.7%
Simplified33.7%
Final simplification33.7%
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(Float64(2.0 * 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[(N[(2.0 * U), $MachinePrecision] * N[(n * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
\sqrt{\left(2 \cdot U\right) \cdot \left(n \cdot t\right)}
\end{array}
Initial program 45.9%
Simplified46.5%
Taylor expanded in t around inf 34.4%
associate-*r*34.4%
Simplified34.4%
Final simplification34.4%
herbie shell --seed 2023278
(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*))))))