
(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 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (n U t l Om U*) :precision binary64 (sqrt (* (* (* 2.0 n) U) (- (- t (* 2.0 (/ (* l l) Om))) (* (* n (pow (/ l Om) 2.0)) (- U U*))))))
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * pow((l / Om), 2.0)) * (U - U_42_)))));
}
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt((((2.0d0 * n) * u) * ((t - (2.0d0 * ((l * l) / om))) - ((n * ((l / om) ** 2.0d0)) * (u - u_42)))))
end function
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * Math.pow((l / Om), 2.0)) * (U - U_42_)))));
}
def code(n, U, t, l, Om, U_42_): return math.sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * math.pow((l / Om), 2.0)) * (U - U_42_)))))
function code(n, U, t, l, Om, U_42_) return sqrt(Float64(Float64(Float64(2.0 * n) * U) * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) - Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U - U_42_))))) end
function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((((2.0 * n) * U) * ((t - (2.0 * ((l * l) / Om))) - ((n * ((l / Om) ^ 2.0)) * (U - U_42_))))); end
code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision] * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left(\left(2 \cdot n\right) \cdot U\right) \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) - \left(n \cdot {\left(\frac{\ell}{Om}\right)}^{2}\right) \cdot \left(U - U*\right)\right)}
\end{array}
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* (* 2.0 n) U))
(t_2
(*
t_1
(+
(- t (* 2.0 (/ (* l l) Om)))
(* (* n (pow (/ l Om) 2.0)) (- U* U))))))
(if (<= t_2 0.0)
(sqrt
(*
U
(* (* 2.0 n) (+ t (/ (* l (+ (* l -2.0) (/ U* (/ Om (* n l))))) Om)))))
(if (<= t_2 INFINITY)
(sqrt
(fma
t_1
t
(*
2.0
(* (/ l Om) (* (fma l -2.0 (* (* n (/ l Om)) (- U* U))) (* n U))))))
(*
(sqrt (/ (* U (* n (- (/ (* n (- 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 = (2.0 * n) * U;
double t_2 = t_1 * ((t - (2.0 * ((l * l) / Om))) + ((n * pow((l / Om), 2.0)) * (U_42_ - U)));
double tmp;
if (t_2 <= 0.0) {
tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om)))));
} else if (t_2 <= ((double) INFINITY)) {
tmp = sqrt(fma(t_1, t, (2.0 * ((l / Om) * (fma(l, -2.0, ((n * (l / Om)) * (U_42_ - U))) * (n * U))))));
} else {
tmp = sqrt(((U * (n * (((n * (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(2.0 * n) * U) t_2 = Float64(t_1 * 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_2 <= 0.0) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + Float64(U_42_ / Float64(Om / Float64(n * l))))) / Om))))); elseif (t_2 <= Inf) tmp = sqrt(fma(t_1, t, Float64(2.0 * Float64(Float64(l / Om) * Float64(fma(l, -2.0, Float64(Float64(n * Float64(l / Om)) * Float64(U_42_ - U))) * Float64(n * U)))))); else tmp = Float64(sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 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[(2.0 * n), $MachinePrecision] * U), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, 0.0], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + N[(U$42$ / N[(Om / N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$2, Infinity], N[Sqrt[N[(t$95$1 * t + N[(2.0 * N[(N[(l / Om), $MachinePrecision] * N[(N[(l * -2.0 + N[(N[(n * N[(l / Om), $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \left(2 \cdot n\right) \cdot U\\
t_2 := t_1 \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_2 \leq 0:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + \frac{U*}{\frac{Om}{n \cdot \ell}}\right)}{Om}\right)\right)}\\
\mathbf{elif}\;t_2 \leq \infty:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(t_1, t, 2 \cdot \left(\frac{\ell}{Om} \cdot \left(\mathsf{fma}\left(\ell, -2, \left(n \cdot \frac{\ell}{Om}\right) \cdot \left(U* - U\right)\right) \cdot \left(n \cdot U\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}} \cdot \left(\ell \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) < 0.0Initial program 5.3%
Simplified5.3%
Applied egg-rr13.4%
pow-sqr13.4%
metadata-eval13.4%
unpow1/213.4%
associate-*r*13.4%
distribute-lft-out13.4%
associate-*r*13.4%
associate-*r*40.9%
*-commutative40.9%
associate-*l*40.9%
associate-*r*40.9%
associate-*r*45.8%
Simplified45.8%
Taylor expanded in U around 0 45.8%
associate-*r*45.8%
mul-1-neg45.8%
associate-/l*45.8%
Simplified45.8%
if 0.0 < (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) < +inf.0Initial program 70.3%
Simplified66.5%
Applied egg-rr67.8%
pow-sqr68.0%
metadata-eval68.0%
unpow1/266.5%
associate-*r*66.5%
distribute-lft-out64.7%
associate-*r*64.7%
associate-*r*60.1%
*-commutative60.1%
associate-*l*60.0%
associate-*r*60.0%
associate-*r*59.5%
Simplified60.1%
Applied egg-rr73.5%
if +inf.0 < (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) Initial program 0.0%
Simplified2.8%
Applied egg-rr32.5%
pow-sqr32.5%
metadata-eval32.5%
unpow1/232.5%
associate-*r*32.5%
distribute-lft-out32.5%
associate-*r*32.5%
associate-*r*33.6%
*-commutative33.6%
associate-*l*28.9%
associate-*r*28.9%
associate-*r*32.1%
Simplified36.9%
Applied egg-rr39.6%
Taylor expanded in l around inf 35.5%
Final simplification63.2%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (/ U* (/ Om (* n l))))
(t_2 (* (* 2.0 n) U))
(t_3
(*
t_2
(+
(- t (* 2.0 (/ (* l l) Om)))
(* (* n (pow (/ l Om) 2.0)) (- U* U))))))
(if (<= t_3 0.0)
(sqrt (* U (* (* 2.0 n) (+ t (/ (* l (+ (* l -2.0) t_1)) Om)))))
(if (<= t_3 INFINITY)
(sqrt (fma t_2 t (* 2.0 (* (/ l Om) (* (* n U) (fma -2.0 l t_1))))))
(*
(sqrt (/ (* U (* n (- (/ (* n (- 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 = U_42_ / (Om / (n * l));
double t_2 = (2.0 * n) * U;
double t_3 = t_2 * ((t - (2.0 * ((l * l) / Om))) + ((n * pow((l / Om), 2.0)) * (U_42_ - U)));
double tmp;
if (t_3 <= 0.0) {
tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + t_1)) / Om)))));
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt(fma(t_2, t, (2.0 * ((l / Om) * ((n * U) * fma(-2.0, l, t_1))))));
} else {
tmp = sqrt(((U * (n * (((n * (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(U_42_ / Float64(Om / Float64(n * l))) t_2 = Float64(Float64(2.0 * n) * U) t_3 = Float64(t_2 * 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_3 <= 0.0) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + t_1)) / Om))))); elseif (t_3 <= Inf) tmp = sqrt(fma(t_2, t, Float64(2.0 * Float64(Float64(l / Om) * Float64(Float64(n * U) * fma(-2.0, l, t_1)))))); else tmp = Float64(sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 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[(U$42$ / N[(Om / N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, 0.0], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[Sqrt[N[(t$95$2 * t + N[(2.0 * N[(N[(l / Om), $MachinePrecision] * N[(N[(n * U), $MachinePrecision] * N[(-2.0 * l + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := \frac{U*}{\frac{Om}{n \cdot \ell}}\\
t_2 := \left(2 \cdot n\right) \cdot U\\
t_3 := t_2 \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_3 \leq 0:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + t_1\right)}{Om}\right)\right)}\\
\mathbf{elif}\;t_3 \leq \infty:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(t_2, t, 2 \cdot \left(\frac{\ell}{Om} \cdot \left(\left(n \cdot U\right) \cdot \mathsf{fma}\left(-2, \ell, t_1\right)\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}} \cdot \left(\ell \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) < 0.0Initial program 5.3%
Simplified5.3%
Applied egg-rr13.4%
pow-sqr13.4%
metadata-eval13.4%
unpow1/213.4%
associate-*r*13.4%
distribute-lft-out13.4%
associate-*r*13.4%
associate-*r*40.9%
*-commutative40.9%
associate-*l*40.9%
associate-*r*40.9%
associate-*r*45.8%
Simplified45.8%
Taylor expanded in U around 0 45.8%
associate-*r*45.8%
mul-1-neg45.8%
associate-/l*45.8%
Simplified45.8%
if 0.0 < (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) < +inf.0Initial program 70.3%
Simplified66.5%
Applied egg-rr67.8%
pow-sqr68.0%
metadata-eval68.0%
unpow1/266.5%
associate-*r*66.5%
distribute-lft-out64.7%
associate-*r*64.7%
associate-*r*60.1%
*-commutative60.1%
associate-*l*60.0%
associate-*r*60.0%
associate-*r*59.5%
Simplified60.1%
Applied egg-rr73.5%
Taylor expanded in U around 0 68.5%
associate-*r*71.4%
*-commutative71.4%
fma-def71.4%
*-commutative71.4%
associate-/l*73.0%
*-commutative73.0%
Simplified73.0%
if +inf.0 < (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) Initial program 0.0%
Simplified2.8%
Applied egg-rr32.5%
pow-sqr32.5%
metadata-eval32.5%
unpow1/232.5%
associate-*r*32.5%
distribute-lft-out32.5%
associate-*r*32.5%
associate-*r*33.6%
*-commutative33.6%
associate-*l*28.9%
associate-*r*28.9%
associate-*r*32.1%
Simplified36.9%
Applied egg-rr39.6%
Taylor expanded in l around inf 35.5%
Final simplification62.9%
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 (* (* 2.0 n) U))
(t_3 (* t_2 (+ (- t (* 2.0 (/ (* l l) Om))) t_1))))
(if (<= t_3 0.0)
(sqrt
(*
U
(* (* 2.0 n) (+ t (/ (* l (+ (* l -2.0) (/ U* (/ Om (* n l))))) Om)))))
(if (<= t_3 2e+303)
(sqrt (* t_2 (+ (- t (* 2.0 (* l (/ l Om)))) t_1)))
(*
(sqrt (/ (* U (* n (- (/ (* n (- 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_42_ - U);
double t_2 = (2.0 * n) * U;
double t_3 = t_2 * ((t - (2.0 * ((l * l) / Om))) + t_1);
double tmp;
if (t_3 <= 0.0) {
tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om)))));
} else if (t_3 <= 2e+303) {
tmp = sqrt((t_2 * ((t - (2.0 * (l * (l / Om)))) + t_1)));
} else {
tmp = sqrt(((U * (n * (((n * (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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = (n * ((l / om) ** 2.0d0)) * (u_42 - u)
t_2 = (2.0d0 * n) * u
t_3 = t_2 * ((t - (2.0d0 * ((l * l) / om))) + t_1)
if (t_3 <= 0.0d0) then
tmp = sqrt((u * ((2.0d0 * n) * (t + ((l * ((l * (-2.0d0)) + (u_42 / (om / (n * l))))) / om)))))
else if (t_3 <= 2d+303) then
tmp = sqrt((t_2 * ((t - (2.0d0 * (l * (l / om)))) + t_1)))
else
tmp = sqrt(((u * (n * (((n * (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 = (n * Math.pow((l / Om), 2.0)) * (U_42_ - U);
double t_2 = (2.0 * n) * U;
double t_3 = t_2 * ((t - (2.0 * ((l * l) / Om))) + t_1);
double tmp;
if (t_3 <= 0.0) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om)))));
} else if (t_3 <= 2e+303) {
tmp = Math.sqrt((t_2 * ((t - (2.0 * (l * (l / Om)))) + t_1)));
} else {
tmp = Math.sqrt(((U * (n * (((n * (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 = (n * math.pow((l / Om), 2.0)) * (U_42_ - U) t_2 = (2.0 * n) * U t_3 = t_2 * ((t - (2.0 * ((l * l) / Om))) + t_1) tmp = 0 if t_3 <= 0.0: tmp = math.sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om))))) elif t_3 <= 2e+303: tmp = math.sqrt((t_2 * ((t - (2.0 * (l * (l / Om)))) + t_1))) else: tmp = math.sqrt(((U * (n * (((n * (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 = Float64(Float64(n * (Float64(l / Om) ^ 2.0)) * Float64(U_42_ - U)) t_2 = Float64(Float64(2.0 * n) * U) t_3 = Float64(t_2 * Float64(Float64(t - Float64(2.0 * Float64(Float64(l * l) / Om))) + t_1)) tmp = 0.0 if (t_3 <= 0.0) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + Float64(U_42_ / Float64(Om / Float64(n * l))))) / Om))))); elseif (t_3 <= 2e+303) tmp = sqrt(Float64(t_2 * Float64(Float64(t - Float64(2.0 * Float64(l * Float64(l / Om)))) + t_1))); else tmp = Float64(sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 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 = (n * ((l / Om) ^ 2.0)) * (U_42_ - U); t_2 = (2.0 * n) * U; t_3 = t_2 * ((t - (2.0 * ((l * l) / Om))) + t_1); tmp = 0.0; if (t_3 <= 0.0) tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om))))); elseif (t_3 <= 2e+303) tmp = sqrt((t_2 * ((t - (2.0 * (l * (l / Om)))) + t_1))); else tmp = sqrt(((U * (n * (((n * (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[(N[(n * N[Power[N[(l / Om), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(2.0 * n), $MachinePrecision] * U), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 * N[(N[(t - N[(2.0 * N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, 0.0], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + N[(U$42$ / N[(Om / N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[t$95$3, 2e+303], N[Sqrt[N[(t$95$2 * N[(N[(t - N[(2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision] * 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 := \left(2 \cdot n\right) \cdot U\\
t_3 := t_2 \cdot \left(\left(t - 2 \cdot \frac{\ell \cdot \ell}{Om}\right) + t_1\right)\\
\mathbf{if}\;t_3 \leq 0:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + \frac{U*}{\frac{Om}{n \cdot \ell}}\right)}{Om}\right)\right)}\\
\mathbf{elif}\;t_3 \leq 2 \cdot 10^{+303}:\\
\;\;\;\;\sqrt{t_2 \cdot \left(\left(t - 2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right) + t_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}} \cdot \left(\ell \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 2 n) U) (-.f64 (-.f64 t (*.f64 2 (/.f64 (*.f64 l l) Om))) (*.f64 (*.f64 n (pow.f64 (/.f64 l Om) 2)) (-.f64 U U*)))) < 0.0Initial program 5.3%
Simplified5.3%
Applied egg-rr13.4%
pow-sqr13.4%
metadata-eval13.4%
unpow1/213.4%
associate-*r*13.4%
distribute-lft-out13.4%
associate-*r*13.4%
associate-*r*40.9%
*-commutative40.9%
associate-*l*40.9%
associate-*r*40.9%
associate-*r*45.8%
Simplified45.8%
Taylor expanded in U around 0 45.8%
associate-*r*45.8%
mul-1-neg45.8%
associate-/l*45.8%
Simplified45.8%
if 0.0 < (*.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*)))) < 2e303Initial program 99.2%
associate-*l/99.2%
Applied egg-rr99.2%
if 2e303 < (*.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 21.7%
Simplified23.3%
Applied egg-rr36.1%
pow-sqr36.1%
metadata-eval36.1%
unpow1/233.9%
associate-*r*33.9%
distribute-lft-out31.3%
associate-*r*31.3%
associate-*r*30.9%
*-commutative30.9%
associate-*l*29.2%
associate-*r*29.2%
associate-*r*29.5%
Simplified35.5%
Applied egg-rr42.5%
Taylor expanded in l around inf 23.1%
Final simplification55.7%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 9.2e+126)
(sqrt
(*
U
(* (* 2.0 n) (+ t (/ (* l (+ (* l -2.0) (/ U* (/ Om (* n l))))) Om)))))
(*
(sqrt (/ (* U (* n (- (/ (* n (- 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 tmp;
if (l <= 9.2e+126) {
tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om)))));
} else {
tmp = sqrt(((U * (n * (((n * (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) :: tmp
if (l <= 9.2d+126) then
tmp = sqrt((u * ((2.0d0 * n) * (t + ((l * ((l * (-2.0d0)) + (u_42 / (om / (n * l))))) / om)))))
else
tmp = sqrt(((u * (n * (((n * (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 tmp;
if (l <= 9.2e+126) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om)))));
} else {
tmp = Math.sqrt(((U * (n * (((n * (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_): tmp = 0 if l <= 9.2e+126: tmp = math.sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om))))) else: tmp = math.sqrt(((U * (n * (((n * (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_) tmp = 0.0 if (l <= 9.2e+126) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + Float64(U_42_ / Float64(Om / Float64(n * l))))) / Om))))); else tmp = Float64(sqrt(Float64(Float64(U * Float64(n * Float64(Float64(Float64(n * Float64(U_42_ - U)) / Om) - 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_) tmp = 0.0; if (l <= 9.2e+126) tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om))))); else tmp = sqrt(((U * (n * (((n * (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$_] := If[LessEqual[l, 9.2e+126], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + N[(U$42$ / N[(Om / N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[N[(N[(U * N[(n * N[(N[(N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision] * N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 9.2 \cdot 10^{+126}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + \frac{U*}{\frac{Om}{n \cdot \ell}}\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{U \cdot \left(n \cdot \left(\frac{n \cdot \left(U* - U\right)}{Om} - 2\right)\right)}{Om}} \cdot \left(\ell \cdot \sqrt{2}\right)\\
\end{array}
\end{array}
if l < 9.2000000000000002e126Initial program 53.8%
Simplified49.5%
Applied egg-rr55.6%
pow-sqr55.8%
metadata-eval55.8%
unpow1/254.6%
associate-*r*54.6%
distribute-lft-out53.2%
associate-*r*53.2%
associate-*r*54.4%
*-commutative54.4%
associate-*l*53.5%
associate-*r*53.5%
associate-*r*54.3%
Simplified54.8%
Taylor expanded in U around 0 57.9%
associate-*r*57.9%
mul-1-neg57.9%
associate-/l*59.7%
Simplified59.7%
if 9.2000000000000002e126 < l Initial program 17.2%
Simplified30.3%
Applied egg-rr44.1%
pow-sqr44.0%
metadata-eval44.0%
unpow1/244.0%
associate-*r*44.0%
distribute-lft-out44.0%
associate-*r*44.0%
associate-*r*42.7%
*-commutative42.7%
associate-*l*42.3%
associate-*r*42.3%
associate-*r*42.9%
Simplified49.4%
Applied egg-rr47.2%
Taylor expanded in l around inf 53.1%
Final simplification58.9%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 2.2e+67)
(pow (* U (* n (* 2.0 t))) 0.5)
(sqrt
(*
2.0
(/ (* U (* l (* n (+ (* l -2.0) (/ (* l (* n (- U* U))) Om))))) Om)))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 2.2e+67) {
tmp = pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = sqrt((2.0 * ((U * (l * (n * ((l * -2.0) + ((l * (n * (U_42_ - U))) / Om))))) / Om)));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 2.2d+67) then
tmp = (u * (n * (2.0d0 * t))) ** 0.5d0
else
tmp = sqrt((2.0d0 * ((u * (l * (n * ((l * (-2.0d0)) + ((l * (n * (u_42 - u))) / om))))) / om)))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 2.2e+67) {
tmp = Math.pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = Math.sqrt((2.0 * ((U * (l * (n * ((l * -2.0) + ((l * (n * (U_42_ - U))) / Om))))) / Om)));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 2.2e+67: tmp = math.pow((U * (n * (2.0 * t))), 0.5) else: tmp = math.sqrt((2.0 * ((U * (l * (n * ((l * -2.0) + ((l * (n * (U_42_ - U))) / Om))))) / Om))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 2.2e+67) tmp = Float64(U * Float64(n * Float64(2.0 * t))) ^ 0.5; else tmp = sqrt(Float64(2.0 * Float64(Float64(U * Float64(l * Float64(n * Float64(Float64(l * -2.0) + Float64(Float64(l * Float64(n * Float64(U_42_ - U))) / Om))))) / Om))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 2.2e+67) tmp = (U * (n * (2.0 * t))) ^ 0.5; else tmp = sqrt((2.0 * ((U * (l * (n * ((l * -2.0) + ((l * (n * (U_42_ - U))) / Om))))) / Om))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 2.2e+67], N[Power[N[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(2.0 * N[(N[(U * N[(l * N[(n * N[(N[(l * -2.0), $MachinePrecision] + N[(N[(l * N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 2.2 \cdot 10^{+67}:\\
\;\;\;\;{\left(U \cdot \left(n \cdot \left(2 \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \frac{U \cdot \left(\ell \cdot \left(n \cdot \left(\ell \cdot -2 + \frac{\ell \cdot \left(n \cdot \left(U* - U\right)\right)}{Om}\right)\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 2.2e67Initial program 54.1%
Simplified49.7%
Taylor expanded in t around inf 42.5%
pow1/244.8%
*-commutative44.8%
associate-*l*44.8%
*-commutative44.8%
associate-*r*44.8%
*-commutative44.8%
*-commutative44.8%
*-commutative44.8%
associate-*l*44.8%
Applied egg-rr44.8%
if 2.2e67 < l Initial program 22.2%
Simplified32.9%
Applied egg-rr46.7%
pow-sqr46.6%
metadata-eval46.6%
unpow1/246.6%
associate-*r*46.6%
distribute-lft-out46.6%
associate-*r*46.6%
associate-*r*46.4%
*-commutative46.4%
associate-*l*46.1%
associate-*r*46.1%
associate-*r*49.0%
Simplified54.3%
Taylor expanded in t around 0 52.2%
Final simplification45.9%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 5.6e+84)
(sqrt (* U (* (* 2.0 n) (+ t (* (/ (* l l) Om) -2.0)))))
(sqrt
(*
U
(* 2.0 (/ l (/ Om (* n (+ (* l -2.0) (* (/ l Om) (* n (- U* U))))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 5.6e+84) {
tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U))))))))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 5.6d+84) then
tmp = sqrt((u * ((2.0d0 * n) * (t + (((l * l) / om) * (-2.0d0))))))
else
tmp = sqrt((u * (2.0d0 * (l / (om / (n * ((l * (-2.0d0)) + ((l / om) * (n * (u_42 - u))))))))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 5.6e+84) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = Math.sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U))))))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 5.6e+84: tmp = math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))) else: tmp = math.sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U)))))))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 5.6e+84) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(Float64(l * l) / Om) * -2.0))))); else tmp = sqrt(Float64(U * Float64(2.0 * Float64(l / Float64(Om / Float64(n * Float64(Float64(l * -2.0) + Float64(Float64(l / Om) * Float64(n * Float64(U_42_ - U)))))))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 5.6e+84) tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))); else tmp = sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U)))))))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 5.6e+84], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(U * N[(2.0 * N[(l / N[(Om / N[(n * N[(N[(l * -2.0), $MachinePrecision] + N[(N[(l / Om), $MachinePrecision] * N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 5.6 \cdot 10^{+84}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \ell}{Om} \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(2 \cdot \frac{\ell}{\frac{Om}{n \cdot \left(\ell \cdot -2 + \frac{\ell}{Om} \cdot \left(n \cdot \left(U* - U\right)\right)\right)}}\right)}\\
\end{array}
\end{array}
if l < 5.59999999999999963e84Initial program 54.0%
Simplified49.7%
Applied egg-rr55.9%
pow-sqr56.1%
metadata-eval56.1%
unpow1/254.9%
associate-*r*54.9%
distribute-lft-out53.5%
associate-*r*53.5%
associate-*r*54.5%
*-commutative54.5%
associate-*l*53.6%
associate-*r*53.6%
associate-*r*54.0%
Simplified54.6%
Taylor expanded in n around 0 47.4%
associate-*r*47.4%
unpow247.4%
Simplified47.4%
if 5.59999999999999963e84 < l Initial program 20.6%
Simplified31.9%
Applied egg-rr43.7%
pow-sqr43.7%
metadata-eval43.7%
unpow1/243.7%
associate-*r*43.7%
distribute-lft-out43.7%
associate-*r*43.7%
associate-*r*43.5%
*-commutative43.5%
associate-*l*43.1%
associate-*r*43.1%
associate-*r*46.2%
Simplified51.8%
Taylor expanded in t around 0 47.0%
associate-/l*49.9%
associate-*l/49.6%
Simplified49.6%
Final simplification47.7%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 9.2e+120)
(sqrt
(*
U
(* (* 2.0 n) (+ t (/ (* l (+ (* l -2.0) (/ U* (/ Om (* n l))))) Om)))))
(sqrt
(*
U
(* 2.0 (/ l (/ Om (* n (+ (* l -2.0) (* (/ l Om) (* n (- U* U))))))))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 9.2e+120) {
tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om)))));
} else {
tmp = sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U))))))))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 9.2d+120) then
tmp = sqrt((u * ((2.0d0 * n) * (t + ((l * ((l * (-2.0d0)) + (u_42 / (om / (n * l))))) / om)))))
else
tmp = sqrt((u * (2.0d0 * (l / (om / (n * ((l * (-2.0d0)) + ((l / om) * (n * (u_42 - u))))))))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 9.2e+120) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om)))));
} else {
tmp = Math.sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U))))))))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 9.2e+120: tmp = math.sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om))))) else: tmp = math.sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U)))))))))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 9.2e+120) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(l * Float64(Float64(l * -2.0) + Float64(U_42_ / Float64(Om / Float64(n * l))))) / Om))))); else tmp = sqrt(Float64(U * Float64(2.0 * Float64(l / Float64(Om / Float64(n * Float64(Float64(l * -2.0) + Float64(Float64(l / Om) * Float64(n * Float64(U_42_ - U)))))))))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 9.2e+120) tmp = sqrt((U * ((2.0 * n) * (t + ((l * ((l * -2.0) + (U_42_ / (Om / (n * l))))) / Om))))); else tmp = sqrt((U * (2.0 * (l / (Om / (n * ((l * -2.0) + ((l / Om) * (n * (U_42_ - U)))))))))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 9.2e+120], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(l * N[(N[(l * -2.0), $MachinePrecision] + N[(U$42$ / N[(Om / N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(U * N[(2.0 * N[(l / N[(Om / N[(n * N[(N[(l * -2.0), $MachinePrecision] + N[(N[(l / Om), $MachinePrecision] * N[(n * N[(U$42$ - U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 9.2 \cdot 10^{+120}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \left(\ell \cdot -2 + \frac{U*}{\frac{Om}{n \cdot \ell}}\right)}{Om}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(2 \cdot \frac{\ell}{\frac{Om}{n \cdot \left(\ell \cdot -2 + \frac{\ell}{Om} \cdot \left(n \cdot \left(U* - U\right)\right)\right)}}\right)}\\
\end{array}
\end{array}
if l < 9.1999999999999997e120Initial program 53.8%
Simplified49.5%
Applied egg-rr55.6%
pow-sqr55.8%
metadata-eval55.8%
unpow1/254.6%
associate-*r*54.6%
distribute-lft-out53.2%
associate-*r*53.2%
associate-*r*54.4%
*-commutative54.4%
associate-*l*53.5%
associate-*r*53.5%
associate-*r*54.3%
Simplified54.8%
Taylor expanded in U around 0 57.9%
associate-*r*57.9%
mul-1-neg57.9%
associate-/l*59.7%
Simplified59.7%
if 9.1999999999999997e120 < l Initial program 17.2%
Simplified30.3%
Applied egg-rr44.1%
pow-sqr44.0%
metadata-eval44.0%
unpow1/244.0%
associate-*r*44.0%
distribute-lft-out44.0%
associate-*r*44.0%
associate-*r*42.7%
*-commutative42.7%
associate-*l*42.3%
associate-*r*42.3%
associate-*r*42.9%
Simplified49.4%
Taylor expanded in t around 0 41.7%
associate-/l*44.9%
associate-*l/47.8%
Simplified47.8%
Final simplification58.2%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(if (<= l 1.06e+68)
(pow (* U (* n (* 2.0 t))) 0.5)
(sqrt
(* U (* -2.0 (/ (* (* l (* n l)) (+ 2.0 (/ n (/ Om (- U U*))))) Om))))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.06e+68) {
tmp = pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = sqrt((U * (-2.0 * (((l * (n * l)) * (2.0 + (n / (Om / (U - U_42_))))) / Om))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.06d+68) then
tmp = (u * (n * (2.0d0 * t))) ** 0.5d0
else
tmp = sqrt((u * ((-2.0d0) * (((l * (n * l)) * (2.0d0 + (n / (om / (u - u_42))))) / om))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.06e+68) {
tmp = Math.pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = Math.sqrt((U * (-2.0 * (((l * (n * l)) * (2.0 + (n / (Om / (U - U_42_))))) / Om))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.06e+68: tmp = math.pow((U * (n * (2.0 * t))), 0.5) else: tmp = math.sqrt((U * (-2.0 * (((l * (n * l)) * (2.0 + (n / (Om / (U - U_42_))))) / Om)))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.06e+68) tmp = Float64(U * Float64(n * Float64(2.0 * t))) ^ 0.5; else tmp = sqrt(Float64(U * Float64(-2.0 * Float64(Float64(Float64(l * Float64(n * l)) * Float64(2.0 + Float64(n / Float64(Om / Float64(U - U_42_))))) / Om)))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.06e+68) tmp = (U * (n * (2.0 * t))) ^ 0.5; else tmp = sqrt((U * (-2.0 * (((l * (n * l)) * (2.0 + (n / (Om / (U - U_42_))))) / Om)))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.06e+68], N[Power[N[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(U * N[(-2.0 * N[(N[(N[(l * N[(n * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 + N[(n / N[(Om / N[(U - U$42$), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.06 \cdot 10^{+68}:\\
\;\;\;\;{\left(U \cdot \left(n \cdot \left(2 \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(-2 \cdot \frac{\left(\ell \cdot \left(n \cdot \ell\right)\right) \cdot \left(2 + \frac{n}{\frac{Om}{U - U*}}\right)}{Om}\right)}\\
\end{array}
\end{array}
if l < 1.06e68Initial program 54.1%
Simplified49.7%
Taylor expanded in t around inf 42.5%
pow1/244.8%
*-commutative44.8%
associate-*l*44.8%
*-commutative44.8%
associate-*r*44.8%
*-commutative44.8%
*-commutative44.8%
*-commutative44.8%
associate-*l*44.8%
Applied egg-rr44.8%
if 1.06e68 < l Initial program 22.2%
Simplified32.9%
Applied egg-rr46.7%
pow-sqr46.6%
metadata-eval46.6%
unpow1/246.6%
associate-*r*46.6%
distribute-lft-out46.6%
associate-*r*46.6%
associate-*r*46.4%
*-commutative46.4%
associate-*l*46.1%
associate-*r*46.1%
associate-*r*49.0%
Simplified54.3%
Taylor expanded in l around inf 44.5%
associate-*r*44.5%
unpow244.5%
associate-/l*44.5%
Simplified44.5%
Taylor expanded in l around 0 44.5%
unpow244.5%
associate-*l*49.8%
Simplified49.8%
Final simplification45.6%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 1.85e+67) (pow (* U (* n (* 2.0 t))) 0.5) (sqrt (* U (* -2.0 (/ (* (* n (* l l)) (- 2.0 (/ U* (/ Om n)))) Om))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.85e+67) {
tmp = pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = sqrt((U * (-2.0 * (((n * (l * l)) * (2.0 - (U_42_ / (Om / n)))) / Om))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.85d+67) then
tmp = (u * (n * (2.0d0 * t))) ** 0.5d0
else
tmp = sqrt((u * ((-2.0d0) * (((n * (l * l)) * (2.0d0 - (u_42 / (om / n)))) / om))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.85e+67) {
tmp = Math.pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = Math.sqrt((U * (-2.0 * (((n * (l * l)) * (2.0 - (U_42_ / (Om / n)))) / Om))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.85e+67: tmp = math.pow((U * (n * (2.0 * t))), 0.5) else: tmp = math.sqrt((U * (-2.0 * (((n * (l * l)) * (2.0 - (U_42_ / (Om / n)))) / Om)))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.85e+67) tmp = Float64(U * Float64(n * Float64(2.0 * t))) ^ 0.5; else tmp = sqrt(Float64(U * Float64(-2.0 * Float64(Float64(Float64(n * Float64(l * l)) * Float64(2.0 - Float64(U_42_ / Float64(Om / n)))) / Om)))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.85e+67) tmp = (U * (n * (2.0 * t))) ^ 0.5; else tmp = sqrt((U * (-2.0 * (((n * (l * l)) * (2.0 - (U_42_ / (Om / n)))) / Om)))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.85e+67], N[Power[N[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(U * N[(-2.0 * N[(N[(N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 - N[(U$42$ / N[(Om / n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.85 \cdot 10^{+67}:\\
\;\;\;\;{\left(U \cdot \left(n \cdot \left(2 \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{U \cdot \left(-2 \cdot \frac{\left(n \cdot \left(\ell \cdot \ell\right)\right) \cdot \left(2 - \frac{U*}{\frac{Om}{n}}\right)}{Om}\right)}\\
\end{array}
\end{array}
if l < 1.8499999999999999e67Initial program 54.1%
Simplified49.7%
Taylor expanded in t around inf 42.5%
pow1/244.8%
*-commutative44.8%
associate-*l*44.8%
*-commutative44.8%
associate-*r*44.8%
*-commutative44.8%
*-commutative44.8%
*-commutative44.8%
associate-*l*44.8%
Applied egg-rr44.8%
if 1.8499999999999999e67 < l Initial program 22.2%
Simplified32.9%
Applied egg-rr46.7%
pow-sqr46.6%
metadata-eval46.6%
unpow1/246.6%
associate-*r*46.6%
distribute-lft-out46.6%
associate-*r*46.6%
associate-*r*46.4%
*-commutative46.4%
associate-*l*46.1%
associate-*r*46.1%
associate-*r*49.0%
Simplified54.3%
Taylor expanded in l around inf 44.5%
associate-*r*44.5%
unpow244.5%
associate-/l*44.5%
Simplified44.5%
Taylor expanded in U around 0 44.5%
mul-1-neg44.5%
associate-/l*44.5%
Simplified44.5%
Final simplification44.8%
NOTE: l should be positive before calling this function
(FPCore (n U t l Om U*)
:precision binary64
(let* ((t_1 (* U (* n (* 2.0 t)))))
(if (<= U* -1.5e-259)
(sqrt (* U (* (* 2.0 n) (+ t (* (/ (* l l) Om) -2.0)))))
(if (<= U* 5.5e+63)
(sqrt (* (- t (* 2.0 (* l (/ l Om)))) (* 2.0 (* n U))))
(pow (* t_1 t_1) 0.25)))))l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double t_1 = U * (n * (2.0 * t));
double tmp;
if (U_42_ <= -1.5e-259) {
tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else if (U_42_ <= 5.5e+63) {
tmp = sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U))));
} else {
tmp = pow((t_1 * t_1), 0.25);
}
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 = u * (n * (2.0d0 * t))
if (u_42 <= (-1.5d-259)) then
tmp = sqrt((u * ((2.0d0 * n) * (t + (((l * l) / om) * (-2.0d0))))))
else if (u_42 <= 5.5d+63) then
tmp = sqrt(((t - (2.0d0 * (l * (l / om)))) * (2.0d0 * (n * u))))
else
tmp = (t_1 * t_1) ** 0.25d0
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 = U * (n * (2.0 * t));
double tmp;
if (U_42_ <= -1.5e-259) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else if (U_42_ <= 5.5e+63) {
tmp = Math.sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U))));
} else {
tmp = Math.pow((t_1 * t_1), 0.25);
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): t_1 = U * (n * (2.0 * t)) tmp = 0 if U_42_ <= -1.5e-259: tmp = math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))) elif U_42_ <= 5.5e+63: tmp = math.sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U)))) else: tmp = math.pow((t_1 * t_1), 0.25) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) t_1 = Float64(U * Float64(n * Float64(2.0 * t))) tmp = 0.0 if (U_42_ <= -1.5e-259) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(Float64(l * l) / Om) * -2.0))))); elseif (U_42_ <= 5.5e+63) tmp = sqrt(Float64(Float64(t - Float64(2.0 * Float64(l * Float64(l / Om)))) * Float64(2.0 * Float64(n * U)))); else tmp = Float64(t_1 * t_1) ^ 0.25; end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) t_1 = U * (n * (2.0 * t)); tmp = 0.0; if (U_42_ <= -1.5e-259) tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))); elseif (U_42_ <= 5.5e+63) tmp = sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U)))); else tmp = (t_1 * t_1) ^ 0.25; 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[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[U$42$, -1.5e-259], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[U$42$, 5.5e+63], N[Sqrt[N[(N[(t - N[(2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Power[N[(t$95$1 * t$95$1), $MachinePrecision], 0.25], $MachinePrecision]]]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
t_1 := U \cdot \left(n \cdot \left(2 \cdot t\right)\right)\\
\mathbf{if}\;U* \leq -1.5 \cdot 10^{-259}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \ell}{Om} \cdot -2\right)\right)}\\
\mathbf{elif}\;U* \leq 5.5 \cdot 10^{+63}:\\
\;\;\;\;\sqrt{\left(t - 2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right) \cdot \left(2 \cdot \left(n \cdot U\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(t_1 \cdot t_1\right)}^{0.25}\\
\end{array}
\end{array}
if U* < -1.5000000000000001e-259Initial program 49.9%
Simplified45.5%
Applied egg-rr51.2%
pow-sqr51.3%
metadata-eval51.3%
unpow1/250.3%
associate-*r*50.3%
distribute-lft-out49.3%
associate-*r*49.3%
associate-*r*52.5%
*-commutative52.5%
associate-*l*54.1%
associate-*r*54.1%
associate-*r*55.1%
Simplified55.3%
Taylor expanded in n around 0 46.9%
associate-*r*46.9%
unpow246.9%
Simplified46.9%
if -1.5000000000000001e-259 < U* < 5.50000000000000004e63Initial program 53.5%
Simplified56.1%
Taylor expanded in Om around inf 54.8%
unpow254.8%
associate-*r/57.9%
Simplified57.9%
if 5.50000000000000004e63 < U* Initial program 41.3%
Simplified35.4%
Taylor expanded in t around inf 24.9%
pow1/230.4%
metadata-eval30.4%
pow-prod-up30.3%
pow-prod-down34.7%
Applied egg-rr34.7%
Final simplification48.2%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 6.5e+165) (sqrt (* U (* (* 2.0 n) (+ t (* (/ (* l l) Om) -2.0))))) (sqrt (* 2.0 (* (/ (* U U*) Om) (/ (* (* l l) (* n n)) Om))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 6.5e+165) {
tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = sqrt((2.0 * (((U * U_42_) / Om) * (((l * l) * (n * n)) / Om))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 6.5d+165) then
tmp = sqrt((u * ((2.0d0 * n) * (t + (((l * l) / om) * (-2.0d0))))))
else
tmp = sqrt((2.0d0 * (((u * u_42) / om) * (((l * l) * (n * n)) / om))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 6.5e+165) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = Math.sqrt((2.0 * (((U * U_42_) / Om) * (((l * l) * (n * n)) / Om))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 6.5e+165: tmp = math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))) else: tmp = math.sqrt((2.0 * (((U * U_42_) / Om) * (((l * l) * (n * n)) / Om)))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 6.5e+165) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(Float64(l * l) / Om) * -2.0))))); else tmp = sqrt(Float64(2.0 * Float64(Float64(Float64(U * U_42_) / Om) * Float64(Float64(Float64(l * l) * Float64(n * n)) / Om)))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 6.5e+165) tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))); else tmp = sqrt((2.0 * (((U * U_42_) / Om) * (((l * l) * (n * n)) / Om)))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 6.5e+165], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(2.0 * N[(N[(N[(U * U$42$), $MachinePrecision] / Om), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * N[(n * n), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 6.5 \cdot 10^{+165}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \ell}{Om} \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{2 \cdot \left(\frac{U \cdot U*}{Om} \cdot \frac{\left(\ell \cdot \ell\right) \cdot \left(n \cdot n\right)}{Om}\right)}\\
\end{array}
\end{array}
if l < 6.4999999999999999e165Initial program 53.3%
Simplified49.1%
Applied egg-rr55.1%
pow-sqr55.3%
metadata-eval55.3%
unpow1/254.2%
associate-*r*54.2%
distribute-lft-out52.8%
associate-*r*52.8%
associate-*r*53.9%
*-commutative53.9%
associate-*l*53.0%
associate-*r*53.0%
associate-*r*53.9%
Simplified54.4%
Taylor expanded in n around 0 47.5%
associate-*r*47.5%
unpow247.5%
Simplified47.5%
if 6.4999999999999999e165 < l Initial program 15.7%
Simplified30.5%
Taylor expanded in U* around inf 30.8%
associate-*r*30.7%
unpow230.7%
times-frac30.8%
unpow230.8%
unpow230.8%
Simplified30.8%
Final simplification45.7%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 5.2e+134) (sqrt (* U (* (* 2.0 n) (+ t (* (/ (* l l) Om) -2.0))))) (sqrt (* (* 2.0 (* n U)) (* (/ (* n (* l l)) Om) (/ U* Om))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 5.2e+134) {
tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = sqrt(((2.0 * (n * U)) * (((n * (l * l)) / Om) * (U_42_ / Om))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 5.2d+134) then
tmp = sqrt((u * ((2.0d0 * n) * (t + (((l * l) / om) * (-2.0d0))))))
else
tmp = sqrt(((2.0d0 * (n * u)) * (((n * (l * l)) / om) * (u_42 / om))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 5.2e+134) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = Math.sqrt(((2.0 * (n * U)) * (((n * (l * l)) / Om) * (U_42_ / Om))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 5.2e+134: tmp = math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))) else: tmp = math.sqrt(((2.0 * (n * U)) * (((n * (l * l)) / Om) * (U_42_ / Om)))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 5.2e+134) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(Float64(l * l) / Om) * -2.0))))); else tmp = sqrt(Float64(Float64(2.0 * Float64(n * U)) * Float64(Float64(Float64(n * Float64(l * l)) / Om) * Float64(U_42_ / Om)))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 5.2e+134) tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))); else tmp = sqrt(((2.0 * (n * U)) * (((n * (l * l)) / Om) * (U_42_ / Om)))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 5.2e+134], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(n * N[(l * l), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision] * N[(U$42$ / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 5.2 \cdot 10^{+134}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \ell}{Om} \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(2 \cdot \left(n \cdot U\right)\right) \cdot \left(\frac{n \cdot \left(\ell \cdot \ell\right)}{Om} \cdot \frac{U*}{Om}\right)}\\
\end{array}
\end{array}
if l < 5.2000000000000003e134Initial program 54.0%
Simplified49.7%
Applied egg-rr55.8%
pow-sqr56.0%
metadata-eval56.0%
unpow1/254.8%
associate-*r*54.8%
distribute-lft-out53.4%
associate-*r*53.4%
associate-*r*54.6%
*-commutative54.6%
associate-*l*53.7%
associate-*r*53.7%
associate-*r*54.5%
Simplified55.0%
Taylor expanded in n around 0 48.1%
associate-*r*48.1%
unpow248.1%
Simplified48.1%
if 5.2000000000000003e134 < l Initial program 14.4%
Simplified14.4%
Taylor expanded in U* around inf 30.8%
*-commutative30.8%
unpow230.8%
times-frac31.4%
*-commutative31.4%
unpow231.4%
Simplified31.4%
Final simplification46.1%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= U* -2.1e-258) (sqrt (* U (* (* 2.0 n) (+ t (* (/ (* l l) Om) -2.0))))) (sqrt (* (- t (* 2.0 (* l (/ l Om)))) (* 2.0 (* n U))))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U_42_ <= -2.1e-258) {
tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U))));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (u_42 <= (-2.1d-258)) then
tmp = sqrt((u * ((2.0d0 * n) * (t + (((l * l) / om) * (-2.0d0))))))
else
tmp = sqrt(((t - (2.0d0 * (l * (l / om)))) * (2.0d0 * (n * u))))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (U_42_ <= -2.1e-258) {
tmp = Math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0)))));
} else {
tmp = Math.sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U))));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if U_42_ <= -2.1e-258: tmp = math.sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))) else: tmp = math.sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U)))) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (U_42_ <= -2.1e-258) tmp = sqrt(Float64(U * Float64(Float64(2.0 * n) * Float64(t + Float64(Float64(Float64(l * l) / Om) * -2.0))))); else tmp = sqrt(Float64(Float64(t - Float64(2.0 * Float64(l * Float64(l / Om)))) * Float64(2.0 * Float64(n * U)))); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (U_42_ <= -2.1e-258) tmp = sqrt((U * ((2.0 * n) * (t + (((l * l) / Om) * -2.0))))); else tmp = sqrt(((t - (2.0 * (l * (l / Om)))) * (2.0 * (n * U)))); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[U$42$, -2.1e-258], N[Sqrt[N[(U * N[(N[(2.0 * n), $MachinePrecision] * N[(t + N[(N[(N[(l * l), $MachinePrecision] / Om), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[N[(N[(t - N[(2.0 * N[(l * N[(l / Om), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(n * U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;U* \leq -2.1 \cdot 10^{-258}:\\
\;\;\;\;\sqrt{U \cdot \left(\left(2 \cdot n\right) \cdot \left(t + \frac{\ell \cdot \ell}{Om} \cdot -2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(t - 2 \cdot \left(\ell \cdot \frac{\ell}{Om}\right)\right) \cdot \left(2 \cdot \left(n \cdot U\right)\right)}\\
\end{array}
\end{array}
if U* < -2.0999999999999999e-258Initial program 49.9%
Simplified45.5%
Applied egg-rr51.2%
pow-sqr51.3%
metadata-eval51.3%
unpow1/250.3%
associate-*r*50.3%
distribute-lft-out49.3%
associate-*r*49.3%
associate-*r*52.5%
*-commutative52.5%
associate-*l*54.1%
associate-*r*54.1%
associate-*r*55.1%
Simplified55.3%
Taylor expanded in n around 0 46.9%
associate-*r*46.9%
unpow246.9%
Simplified46.9%
if -2.0999999999999999e-258 < U* Initial program 48.9%
Simplified48.4%
Taylor expanded in Om around inf 44.4%
unpow244.4%
associate-*r/46.5%
Simplified46.5%
Final simplification46.7%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (if (<= l 1.2e+68) (pow (* U (* n (* 2.0 t))) 0.5) (sqrt (/ (* -4.0 (* U (* l (* n l)))) Om))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.2e+68) {
tmp = pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = sqrt(((-4.0 * (U * (l * (n * l)))) / Om));
}
return tmp;
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
real(8) :: tmp
if (l <= 1.2d+68) then
tmp = (u * (n * (2.0d0 * t))) ** 0.5d0
else
tmp = sqrt((((-4.0d0) * (u * (l * (n * l)))) / om))
end if
code = tmp
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
double tmp;
if (l <= 1.2e+68) {
tmp = Math.pow((U * (n * (2.0 * t))), 0.5);
} else {
tmp = Math.sqrt(((-4.0 * (U * (l * (n * l)))) / Om));
}
return tmp;
}
l = abs(l) def code(n, U, t, l, Om, U_42_): tmp = 0 if l <= 1.2e+68: tmp = math.pow((U * (n * (2.0 * t))), 0.5) else: tmp = math.sqrt(((-4.0 * (U * (l * (n * l)))) / Om)) return tmp
l = abs(l) function code(n, U, t, l, Om, U_42_) tmp = 0.0 if (l <= 1.2e+68) tmp = Float64(U * Float64(n * Float64(2.0 * t))) ^ 0.5; else tmp = sqrt(Float64(Float64(-4.0 * Float64(U * Float64(l * Float64(n * l)))) / Om)); end return tmp end
l = abs(l) function tmp_2 = code(n, U, t, l, Om, U_42_) tmp = 0.0; if (l <= 1.2e+68) tmp = (U * (n * (2.0 * t))) ^ 0.5; else tmp = sqrt(((-4.0 * (U * (l * (n * l)))) / Om)); end tmp_2 = tmp; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := If[LessEqual[l, 1.2e+68], N[Power[N[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision], N[Sqrt[N[(N[(-4.0 * N[(U * N[(l * N[(n * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / Om), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
l = |l|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.2 \cdot 10^{+68}:\\
\;\;\;\;{\left(U \cdot \left(n \cdot \left(2 \cdot t\right)\right)\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{-4 \cdot \left(U \cdot \left(\ell \cdot \left(n \cdot \ell\right)\right)\right)}{Om}}\\
\end{array}
\end{array}
if l < 1.20000000000000004e68Initial program 54.1%
Simplified49.7%
Taylor expanded in t around inf 42.5%
pow1/244.8%
*-commutative44.8%
associate-*l*44.8%
*-commutative44.8%
associate-*r*44.8%
*-commutative44.8%
*-commutative44.8%
*-commutative44.8%
associate-*l*44.8%
Applied egg-rr44.8%
if 1.20000000000000004e68 < l Initial program 22.2%
Simplified32.9%
Applied egg-rr46.7%
pow-sqr46.6%
metadata-eval46.6%
unpow1/246.6%
associate-*r*46.6%
distribute-lft-out46.6%
associate-*r*46.6%
associate-*r*46.4%
*-commutative46.4%
associate-*l*46.1%
associate-*r*46.1%
associate-*r*49.0%
Simplified54.3%
Taylor expanded in l around inf 44.5%
associate-*r*44.5%
unpow244.5%
associate-/l*44.5%
Simplified44.5%
Taylor expanded in n around 0 30.7%
associate-*r/30.7%
unpow230.7%
associate-*l*38.4%
Simplified38.4%
Final simplification43.9%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (pow (* U (* n (* 2.0 t))) 0.5))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
return pow((U * (n * (2.0 * 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 = (u * (n * (2.0d0 * 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((U * (n * (2.0 * t))), 0.5);
}
l = abs(l) def code(n, U, t, l, Om, U_42_): return math.pow((U * (n * (2.0 * t))), 0.5)
l = abs(l) function code(n, U, t, l, Om, U_42_) return Float64(U * Float64(n * Float64(2.0 * t))) ^ 0.5 end
l = abs(l) function tmp = code(n, U, t, l, Om, U_42_) tmp = (U * (n * (2.0 * t))) ^ 0.5; end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := N[Power[N[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
{\left(U \cdot \left(n \cdot \left(2 \cdot t\right)\right)\right)}^{0.5}
\end{array}
Initial program 49.3%
Simplified47.2%
Taylor expanded in t around inf 38.1%
pow1/240.5%
*-commutative40.5%
associate-*l*40.5%
*-commutative40.5%
associate-*r*40.5%
*-commutative40.5%
*-commutative40.5%
*-commutative40.5%
associate-*l*40.5%
Applied egg-rr40.5%
Final simplification40.5%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (sqrt (* 2.0 (* U (* n t)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((2.0 * (U * (n * t))));
}
NOTE: l should be positive before calling this function
real(8) function code(n, u, t, l, om, u_42)
real(8), intent (in) :: n
real(8), intent (in) :: u
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: u_42
code = sqrt((2.0d0 * (u * (n * t))))
end function
l = Math.abs(l);
public static double code(double n, double U, double t, double l, double Om, double U_42_) {
return Math.sqrt((2.0 * (U * (n * t))));
}
l = abs(l) def code(n, U, t, l, Om, U_42_): return math.sqrt((2.0 * (U * (n * t))))
l = abs(l) function code(n, U, t, l, Om, U_42_) return sqrt(Float64(2.0 * Float64(U * Float64(n * t)))) end
l = abs(l) function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((2.0 * (U * (n * t)))); end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(2.0 * N[(U * N[(n * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
\sqrt{2 \cdot \left(U \cdot \left(n \cdot t\right)\right)}
\end{array}
Initial program 49.3%
Simplified47.2%
Taylor expanded in t around inf 38.1%
Final simplification38.1%
NOTE: l should be positive before calling this function (FPCore (n U t l Om U*) :precision binary64 (sqrt (* U (* n (* 2.0 t)))))
l = abs(l);
double code(double n, double U, double t, double l, double Om, double U_42_) {
return sqrt((U * (n * (2.0 * 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((u * (n * (2.0d0 * 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((U * (n * (2.0 * t))));
}
l = abs(l) def code(n, U, t, l, Om, U_42_): return math.sqrt((U * (n * (2.0 * t))))
l = abs(l) function code(n, U, t, l, Om, U_42_) return sqrt(Float64(U * Float64(n * Float64(2.0 * t)))) end
l = abs(l) function tmp = code(n, U, t, l, Om, U_42_) tmp = sqrt((U * (n * (2.0 * t)))); end
NOTE: l should be positive before calling this function code[n_, U_, t_, l_, Om_, U$42$_] := N[Sqrt[N[(U * N[(n * N[(2.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
l = |l|\\
\\
\sqrt{U \cdot \left(n \cdot \left(2 \cdot t\right)\right)}
\end{array}
Initial program 49.3%
Simplified47.2%
Taylor expanded in t around inf 38.1%
pow1/240.5%
*-commutative40.5%
associate-*l*40.5%
*-commutative40.5%
associate-*r*40.5%
*-commutative40.5%
*-commutative40.5%
*-commutative40.5%
associate-*l*40.5%
Applied egg-rr40.5%
unpow1/238.1%
Simplified38.1%
Final simplification38.1%
herbie shell --seed 2023297
(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*))))))