
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (cbrt (* k_m (sqrt 2.0)))))
(if (<= k_m 9.2e-14)
(/ 2.0 (pow (* (* t (pow (cbrt l) -2.0)) (* t_1 t_1)) 3.0))
(*
2.0
(/
(* (pow l 2.0) (cos k_m))
(* (pow k_m 2.0) (* t (pow (sin k_m) 2.0))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = cbrt((k_m * sqrt(2.0)));
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / pow(((t * pow(cbrt(l), -2.0)) * (t_1 * t_1)), 3.0);
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k_m)) / (pow(k_m, 2.0) * (t * pow(sin(k_m), 2.0))));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = Math.cbrt((k_m * Math.sqrt(2.0)));
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / Math.pow(((t * Math.pow(Math.cbrt(l), -2.0)) * (t_1 * t_1)), 3.0);
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k_m)) / (Math.pow(k_m, 2.0) * (t * Math.pow(Math.sin(k_m), 2.0))));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = cbrt(Float64(k_m * sqrt(2.0))) tmp = 0.0 if (k_m <= 9.2e-14) tmp = Float64(2.0 / (Float64(Float64(t * (cbrt(l) ^ -2.0)) * Float64(t_1 * t_1)) ^ 3.0)); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k_m)) / Float64((k_m ^ 2.0) * Float64(t * (sin(k_m) ^ 2.0))))); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[Power[N[(k$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, If[LessEqual[k$95$m, 9.2e-14], N[(2.0 / N[Power[N[(N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \sqrt[3]{k\_m \cdot \sqrt{2}}\\
\mathbf{if}\;k\_m \leq 9.2 \cdot 10^{-14}:\\
\;\;\;\;\frac{2}{{\left(\left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right) \cdot \left(t\_1 \cdot t\_1\right)\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k\_m}{{k\_m}^{2} \cdot \left(t \cdot {\sin k\_m}^{2}\right)}\\
\end{array}
\end{array}
if k < 9.19999999999999993e-14Initial program 56.1%
Simplified55.6%
Taylor expanded in k around 0 56.0%
add-cube-cbrt55.9%
pow355.9%
cbrt-prod56.0%
associate-/l/51.1%
unpow251.1%
cbrt-div51.6%
unpow351.6%
add-cbrt-cube60.1%
unpow260.1%
cbrt-prod64.8%
unpow264.8%
div-inv64.8%
pow-flip64.8%
metadata-eval64.8%
Applied egg-rr64.8%
pow1/364.2%
add-sqr-sqrt64.2%
unpow-prod-down64.2%
*-commutative64.2%
sqrt-prod64.2%
sqrt-pow118.1%
metadata-eval18.1%
pow118.1%
*-commutative18.1%
sqrt-prod18.1%
sqrt-pow124.3%
metadata-eval24.3%
pow124.3%
Applied egg-rr24.3%
unpow1/324.4%
unpow1/377.3%
Simplified77.3%
if 9.19999999999999993e-14 < k Initial program 48.4%
Simplified48.4%
Taylor expanded in t around 0 78.0%
Final simplification77.5%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= k_m 3.1e+16)
(/
2.0
(*
(* 2.0 (/ (sin k_m) (cos k_m)))
(pow (* (* t (pow (cbrt l) -2.0)) (cbrt (sin k_m))) 3.0)))
(*
2.0
(/
(* (pow l 2.0) (cos k_m))
(* (pow k_m 2.0) (* t (pow (sin k_m) 2.0)))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 3.1e+16) {
tmp = 2.0 / ((2.0 * (sin(k_m) / cos(k_m))) * pow(((t * pow(cbrt(l), -2.0)) * cbrt(sin(k_m))), 3.0));
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k_m)) / (pow(k_m, 2.0) * (t * pow(sin(k_m), 2.0))));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 3.1e+16) {
tmp = 2.0 / ((2.0 * (Math.sin(k_m) / Math.cos(k_m))) * Math.pow(((t * Math.pow(Math.cbrt(l), -2.0)) * Math.cbrt(Math.sin(k_m))), 3.0));
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k_m)) / (Math.pow(k_m, 2.0) * (t * Math.pow(Math.sin(k_m), 2.0))));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 3.1e+16) tmp = Float64(2.0 / Float64(Float64(2.0 * Float64(sin(k_m) / cos(k_m))) * (Float64(Float64(t * (cbrt(l) ^ -2.0)) * cbrt(sin(k_m))) ^ 3.0))); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k_m)) / Float64((k_m ^ 2.0) * Float64(t * (sin(k_m) ^ 2.0))))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 3.1e+16], N[(2.0 / N[(N[(2.0 * N[(N[Sin[k$95$m], $MachinePrecision] / N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k$95$m], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 3.1 \cdot 10^{+16}:\\
\;\;\;\;\frac{2}{\left(2 \cdot \frac{\sin k\_m}{\cos k\_m}\right) \cdot {\left(\left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right) \cdot \sqrt[3]{\sin k\_m}\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k\_m}{{k\_m}^{2} \cdot \left(t \cdot {\sin k\_m}^{2}\right)}\\
\end{array}
\end{array}
if k < 3.1e16Initial program 55.7%
Simplified55.7%
add-cube-cbrt55.6%
pow355.6%
*-commutative55.6%
cbrt-prod55.6%
cbrt-div56.5%
rem-cbrt-cube67.5%
cbrt-prod79.5%
pow279.5%
Applied egg-rr79.5%
*-commutative79.5%
Simplified79.5%
pow179.5%
div-inv79.5%
pow-flip79.4%
metadata-eval79.4%
Applied egg-rr79.4%
unpow179.4%
Simplified79.4%
Taylor expanded in t around inf 73.0%
if 3.1e16 < k Initial program 49.3%
Simplified49.2%
Taylor expanded in t around 0 76.8%
Final simplification73.8%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= k_m 2.2e+16)
(/
2.0
(*
(pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k_m))) 3.0)
(* 2.0 (/ (sin k_m) (cos k_m)))))
(*
2.0
(/
(* (pow l 2.0) (cos k_m))
(* (pow k_m 2.0) (* t (pow (sin k_m) 2.0)))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 2.2e+16) {
tmp = 2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k_m))), 3.0) * (2.0 * (sin(k_m) / cos(k_m))));
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k_m)) / (pow(k_m, 2.0) * (t * pow(sin(k_m), 2.0))));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 2.2e+16) {
tmp = 2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k_m))), 3.0) * (2.0 * (Math.sin(k_m) / Math.cos(k_m))));
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k_m)) / (Math.pow(k_m, 2.0) * (t * Math.pow(Math.sin(k_m), 2.0))));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 2.2e+16) tmp = Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k_m))) ^ 3.0) * Float64(2.0 * Float64(sin(k_m) / cos(k_m))))); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k_m)) / Float64((k_m ^ 2.0) * Float64(t * (sin(k_m) ^ 2.0))))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 2.2e+16], N[(2.0 / N[(N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k$95$m], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * N[(N[Sin[k$95$m], $MachinePrecision] / N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 2.2 \cdot 10^{+16}:\\
\;\;\;\;\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k\_m}\right)}^{3} \cdot \left(2 \cdot \frac{\sin k\_m}{\cos k\_m}\right)}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k\_m}{{k\_m}^{2} \cdot \left(t \cdot {\sin k\_m}^{2}\right)}\\
\end{array}
\end{array}
if k < 2.2e16Initial program 55.7%
Simplified55.7%
add-cube-cbrt55.6%
pow355.6%
*-commutative55.6%
cbrt-prod55.6%
cbrt-div56.5%
rem-cbrt-cube67.5%
cbrt-prod79.5%
pow279.5%
Applied egg-rr79.5%
*-commutative79.5%
Simplified79.5%
Taylor expanded in t around inf 73.1%
if 2.2e16 < k Initial program 49.3%
Simplified49.2%
Taylor expanded in t around 0 76.8%
Final simplification73.9%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= k_m 9.2e-14)
(/
2.0
(* (pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k_m))) 3.0) (* k_m 2.0)))
(*
2.0
(/
(* (pow l 2.0) (cos k_m))
(* (pow k_m 2.0) (* t (pow (sin k_m) 2.0)))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k_m))), 3.0) * (k_m * 2.0));
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k_m)) / (pow(k_m, 2.0) * (t * pow(sin(k_m), 2.0))));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k_m))), 3.0) * (k_m * 2.0));
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k_m)) / (Math.pow(k_m, 2.0) * (t * Math.pow(Math.sin(k_m), 2.0))));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 9.2e-14) tmp = Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k_m))) ^ 3.0) * Float64(k_m * 2.0))); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k_m)) / Float64((k_m ^ 2.0) * Float64(t * (sin(k_m) ^ 2.0))))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 9.2e-14], N[(2.0 / N[(N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k$95$m], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(k$95$m * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 9.2 \cdot 10^{-14}:\\
\;\;\;\;\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k\_m}\right)}^{3} \cdot \left(k\_m \cdot 2\right)}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k\_m}{{k\_m}^{2} \cdot \left(t \cdot {\sin k\_m}^{2}\right)}\\
\end{array}
\end{array}
if k < 9.19999999999999993e-14Initial program 56.1%
Simplified56.1%
add-cube-cbrt56.0%
pow355.9%
*-commutative55.9%
cbrt-prod55.9%
cbrt-div56.9%
rem-cbrt-cube68.0%
cbrt-prod80.2%
pow280.2%
Applied egg-rr80.2%
*-commutative80.2%
Simplified80.2%
Taylor expanded in k around 0 71.8%
if 9.19999999999999993e-14 < k Initial program 48.4%
Simplified48.4%
Taylor expanded in t around 0 78.0%
Final simplification73.2%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= k_m 9.2e-14)
(/
2.0
(* (pow (* (* t (pow (cbrt l) -2.0)) (cbrt (sin k_m))) 3.0) (* k_m 2.0)))
(/
2.0
(/
(* (pow k_m 2.0) (* t (- 0.5 (/ (cos (* k_m 2.0)) 2.0))))
(* (pow l 2.0) (cos k_m))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / (pow(((t * pow(cbrt(l), -2.0)) * cbrt(sin(k_m))), 3.0) * (k_m * 2.0));
} else {
tmp = 2.0 / ((pow(k_m, 2.0) * (t * (0.5 - (cos((k_m * 2.0)) / 2.0)))) / (pow(l, 2.0) * cos(k_m)));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / (Math.pow(((t * Math.pow(Math.cbrt(l), -2.0)) * Math.cbrt(Math.sin(k_m))), 3.0) * (k_m * 2.0));
} else {
tmp = 2.0 / ((Math.pow(k_m, 2.0) * (t * (0.5 - (Math.cos((k_m * 2.0)) / 2.0)))) / (Math.pow(l, 2.0) * Math.cos(k_m)));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 9.2e-14) tmp = Float64(2.0 / Float64((Float64(Float64(t * (cbrt(l) ^ -2.0)) * cbrt(sin(k_m))) ^ 3.0) * Float64(k_m * 2.0))); else tmp = Float64(2.0 / Float64(Float64((k_m ^ 2.0) * Float64(t * Float64(0.5 - Float64(cos(Float64(k_m * 2.0)) / 2.0)))) / Float64((l ^ 2.0) * cos(k_m)))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 9.2e-14], N[(2.0 / N[(N[Power[N[(N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k$95$m], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(k$95$m * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[(0.5 - N[(N[Cos[N[(k$95$m * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 9.2 \cdot 10^{-14}:\\
\;\;\;\;\frac{2}{{\left(\left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right) \cdot \sqrt[3]{\sin k\_m}\right)}^{3} \cdot \left(k\_m \cdot 2\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{{k\_m}^{2} \cdot \left(t \cdot \left(0.5 - \frac{\cos \left(k\_m \cdot 2\right)}{2}\right)\right)}{{\ell}^{2} \cdot \cos k\_m}}\\
\end{array}
\end{array}
if k < 9.19999999999999993e-14Initial program 56.1%
Simplified56.1%
add-cube-cbrt56.0%
pow355.9%
*-commutative55.9%
cbrt-prod55.9%
cbrt-div56.9%
rem-cbrt-cube68.0%
cbrt-prod80.2%
pow280.2%
Applied egg-rr80.2%
*-commutative80.2%
Simplified80.2%
pow180.2%
div-inv80.2%
pow-flip80.1%
metadata-eval80.1%
Applied egg-rr80.1%
unpow180.1%
Simplified80.1%
Taylor expanded in k around 0 71.7%
if 9.19999999999999993e-14 < k Initial program 48.4%
Simplified48.4%
Taylor expanded in t around 0 77.9%
unpow277.9%
sin-mult77.9%
Applied egg-rr77.9%
div-sub77.9%
+-inverses77.9%
cos-077.9%
metadata-eval77.9%
count-277.9%
*-commutative77.9%
Simplified77.9%
Final simplification73.1%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= k_m 9.2e-14)
(/
2.0
(* (pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k_m))) 3.0) (* k_m 2.0)))
(/
2.0
(/
(* (pow k_m 2.0) (* t (- 0.5 (/ (cos (* k_m 2.0)) 2.0))))
(* (pow l 2.0) (cos k_m))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k_m))), 3.0) * (k_m * 2.0));
} else {
tmp = 2.0 / ((pow(k_m, 2.0) * (t * (0.5 - (cos((k_m * 2.0)) / 2.0)))) / (pow(l, 2.0) * cos(k_m)));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k_m))), 3.0) * (k_m * 2.0));
} else {
tmp = 2.0 / ((Math.pow(k_m, 2.0) * (t * (0.5 - (Math.cos((k_m * 2.0)) / 2.0)))) / (Math.pow(l, 2.0) * Math.cos(k_m)));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 9.2e-14) tmp = Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k_m))) ^ 3.0) * Float64(k_m * 2.0))); else tmp = Float64(2.0 / Float64(Float64((k_m ^ 2.0) * Float64(t * Float64(0.5 - Float64(cos(Float64(k_m * 2.0)) / 2.0)))) / Float64((l ^ 2.0) * cos(k_m)))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 9.2e-14], N[(2.0 / N[(N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k$95$m], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(k$95$m * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[(0.5 - N[(N[Cos[N[(k$95$m * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 9.2 \cdot 10^{-14}:\\
\;\;\;\;\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k\_m}\right)}^{3} \cdot \left(k\_m \cdot 2\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{{k\_m}^{2} \cdot \left(t \cdot \left(0.5 - \frac{\cos \left(k\_m \cdot 2\right)}{2}\right)\right)}{{\ell}^{2} \cdot \cos k\_m}}\\
\end{array}
\end{array}
if k < 9.19999999999999993e-14Initial program 56.1%
Simplified56.1%
add-cube-cbrt56.0%
pow355.9%
*-commutative55.9%
cbrt-prod55.9%
cbrt-div56.9%
rem-cbrt-cube68.0%
cbrt-prod80.2%
pow280.2%
Applied egg-rr80.2%
*-commutative80.2%
Simplified80.2%
Taylor expanded in k around 0 71.8%
if 9.19999999999999993e-14 < k Initial program 48.4%
Simplified48.4%
Taylor expanded in t around 0 77.9%
unpow277.9%
sin-mult77.9%
Applied egg-rr77.9%
div-sub77.9%
+-inverses77.9%
cos-077.9%
metadata-eval77.9%
count-277.9%
*-commutative77.9%
Simplified77.9%
Final simplification73.2%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (* (sin k_m) (/ (pow t 3.0) (* l l)))))
(if (<= t 1.25e-75)
(pow (* l (sqrt (/ (/ 2.0 t) (pow k_m 4.0)))) 2.0)
(if (<= t 2.8e+102)
(/ 2.0 (* t_1 (* (tan k_m) (+ 1.0 (+ 1.0 (/ k_m (* t (/ t k_m))))))))
(if (<= t 8.5e+165)
(/ 2.0 (* (pow (* t (pow (cbrt l) -2.0)) 3.0) (* 2.0 (pow k_m 2.0))))
(/ 2.0 (* (* k_m 2.0) t_1)))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = sin(k_m) * (pow(t, 3.0) / (l * l));
double tmp;
if (t <= 1.25e-75) {
tmp = pow((l * sqrt(((2.0 / t) / pow(k_m, 4.0)))), 2.0);
} else if (t <= 2.8e+102) {
tmp = 2.0 / (t_1 * (tan(k_m) * (1.0 + (1.0 + (k_m / (t * (t / k_m)))))));
} else if (t <= 8.5e+165) {
tmp = 2.0 / (pow((t * pow(cbrt(l), -2.0)), 3.0) * (2.0 * pow(k_m, 2.0)));
} else {
tmp = 2.0 / ((k_m * 2.0) * t_1);
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = Math.sin(k_m) * (Math.pow(t, 3.0) / (l * l));
double tmp;
if (t <= 1.25e-75) {
tmp = Math.pow((l * Math.sqrt(((2.0 / t) / Math.pow(k_m, 4.0)))), 2.0);
} else if (t <= 2.8e+102) {
tmp = 2.0 / (t_1 * (Math.tan(k_m) * (1.0 + (1.0 + (k_m / (t * (t / k_m)))))));
} else if (t <= 8.5e+165) {
tmp = 2.0 / (Math.pow((t * Math.pow(Math.cbrt(l), -2.0)), 3.0) * (2.0 * Math.pow(k_m, 2.0)));
} else {
tmp = 2.0 / ((k_m * 2.0) * t_1);
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(sin(k_m) * Float64((t ^ 3.0) / Float64(l * l))) tmp = 0.0 if (t <= 1.25e-75) tmp = Float64(l * sqrt(Float64(Float64(2.0 / t) / (k_m ^ 4.0)))) ^ 2.0; elseif (t <= 2.8e+102) tmp = Float64(2.0 / Float64(t_1 * Float64(tan(k_m) * Float64(1.0 + Float64(1.0 + Float64(k_m / Float64(t * Float64(t / k_m)))))))); elseif (t <= 8.5e+165) tmp = Float64(2.0 / Float64((Float64(t * (cbrt(l) ^ -2.0)) ^ 3.0) * Float64(2.0 * (k_m ^ 2.0)))); else tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * t_1)); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 1.25e-75], N[Power[N[(l * N[Sqrt[N[(N[(2.0 / t), $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 2.8e+102], N[(2.0 / N[(t$95$1 * N[(N[Tan[k$95$m], $MachinePrecision] * N[(1.0 + N[(1.0 + N[(k$95$m / N[(t * N[(t / k$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.5e+165], N[(2.0 / N[(N[Power[N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \sin k\_m \cdot \frac{{t}^{3}}{\ell \cdot \ell}\\
\mathbf{if}\;t \leq 1.25 \cdot 10^{-75}:\\
\;\;\;\;{\left(\ell \cdot \sqrt{\frac{\frac{2}{t}}{{k\_m}^{4}}}\right)}^{2}\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{+102}:\\
\;\;\;\;\frac{2}{t\_1 \cdot \left(\tan k\_m \cdot \left(1 + \left(1 + \frac{k\_m}{t \cdot \frac{t}{k\_m}}\right)\right)\right)}\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{+165}:\\
\;\;\;\;\frac{2}{{\left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)}^{3} \cdot \left(2 \cdot {k\_m}^{2}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot t\_1}\\
\end{array}
\end{array}
if t < 1.24999999999999995e-75Initial program 47.1%
Simplified44.8%
Taylor expanded in k around 0 42.9%
associate-*r/42.9%
*-commutative42.9%
*-commutative42.9%
times-frac42.3%
Simplified42.3%
Taylor expanded in t around 0 51.7%
associate-*r/51.7%
*-commutative51.7%
associate-/l*51.7%
*-commutative51.7%
Simplified51.7%
add-sqr-sqrt34.8%
pow234.8%
sqrt-prod31.6%
sqrt-pow135.1%
metadata-eval35.1%
pow135.1%
associate-/r*35.1%
Applied egg-rr35.1%
if 1.24999999999999995e-75 < t < 2.80000000000000018e102Initial program 74.0%
Simplified73.9%
unpow273.9%
clear-num73.9%
frac-times74.0%
*-un-lft-identity74.0%
Applied egg-rr74.0%
if 2.80000000000000018e102 < t < 8.5000000000000001e165Initial program 56.1%
Simplified56.0%
Taylor expanded in k around 0 56.0%
add-cube-cbrt56.0%
pow356.0%
associate-/l/55.9%
unpow255.9%
cbrt-div55.9%
unpow355.9%
add-cbrt-cube82.2%
unpow282.2%
cbrt-prod82.0%
unpow282.0%
div-inv81.7%
unpow-prod-down55.9%
pow-flip55.9%
metadata-eval55.9%
Applied egg-rr55.9%
cube-prod81.7%
Simplified81.7%
if 8.5000000000000001e165 < t Initial program 80.0%
Simplified80.0%
Taylor expanded in k around 0 80.0%
Final simplification46.7%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= k_m 9.2e-14)
(/ 2.0 (* (* k_m 2.0) (* (sin k_m) (pow (/ t (pow (cbrt l) 2.0)) 3.0))))
(/
2.0
(/
(* (pow k_m 2.0) (* t (- 0.5 (/ (cos (* k_m 2.0)) 2.0))))
(* (pow l 2.0) (cos k_m))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / ((k_m * 2.0) * (sin(k_m) * pow((t / pow(cbrt(l), 2.0)), 3.0)));
} else {
tmp = 2.0 / ((pow(k_m, 2.0) * (t * (0.5 - (cos((k_m * 2.0)) / 2.0)))) / (pow(l, 2.0) * cos(k_m)));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / ((k_m * 2.0) * (Math.sin(k_m) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)));
} else {
tmp = 2.0 / ((Math.pow(k_m, 2.0) * (t * (0.5 - (Math.cos((k_m * 2.0)) / 2.0)))) / (Math.pow(l, 2.0) * Math.cos(k_m)));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 9.2e-14) tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * Float64(sin(k_m) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))); else tmp = Float64(2.0 / Float64(Float64((k_m ^ 2.0) * Float64(t * Float64(0.5 - Float64(cos(Float64(k_m * 2.0)) / 2.0)))) / Float64((l ^ 2.0) * cos(k_m)))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 9.2e-14], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[(0.5 - N[(N[Cos[N[(k$95$m * 2.0), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 9.2 \cdot 10^{-14}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot \left(\sin k\_m \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{{k\_m}^{2} \cdot \left(t \cdot \left(0.5 - \frac{\cos \left(k\_m \cdot 2\right)}{2}\right)\right)}{{\ell}^{2} \cdot \cos k\_m}}\\
\end{array}
\end{array}
if k < 9.19999999999999993e-14Initial program 56.1%
Simplified56.1%
add-cube-cbrt56.0%
pow356.0%
cbrt-div55.9%
rem-cbrt-cube65.2%
cbrt-prod74.6%
pow274.6%
Applied egg-rr74.6%
Taylor expanded in k around 0 66.1%
if 9.19999999999999993e-14 < k Initial program 48.4%
Simplified48.4%
Taylor expanded in t around 0 77.9%
unpow277.9%
sin-mult77.9%
Applied egg-rr77.9%
div-sub77.9%
+-inverses77.9%
cos-077.9%
metadata-eval77.9%
count-277.9%
*-commutative77.9%
Simplified77.9%
Final simplification68.8%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= k_m 9.2e-14)
(/ 2.0 (* (* k_m 2.0) (* (sin k_m) (pow (/ t (pow (cbrt l) 2.0)) 3.0))))
(/
2.0
(/ (* (pow k_m 2.0) (* t (pow k_m 2.0))) (* (pow l 2.0) (cos k_m))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / ((k_m * 2.0) * (sin(k_m) * pow((t / pow(cbrt(l), 2.0)), 3.0)));
} else {
tmp = 2.0 / ((pow(k_m, 2.0) * (t * pow(k_m, 2.0))) / (pow(l, 2.0) * cos(k_m)));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / ((k_m * 2.0) * (Math.sin(k_m) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)));
} else {
tmp = 2.0 / ((Math.pow(k_m, 2.0) * (t * Math.pow(k_m, 2.0))) / (Math.pow(l, 2.0) * Math.cos(k_m)));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 9.2e-14) tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * Float64(sin(k_m) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))); else tmp = Float64(2.0 / Float64(Float64((k_m ^ 2.0) * Float64(t * (k_m ^ 2.0))) / Float64((l ^ 2.0) * cos(k_m)))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 9.2e-14], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 9.2 \cdot 10^{-14}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot \left(\sin k\_m \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{{k\_m}^{2} \cdot \left(t \cdot {k\_m}^{2}\right)}{{\ell}^{2} \cdot \cos k\_m}}\\
\end{array}
\end{array}
if k < 9.19999999999999993e-14Initial program 56.1%
Simplified56.1%
add-cube-cbrt56.0%
pow356.0%
cbrt-div55.9%
rem-cbrt-cube65.2%
cbrt-prod74.6%
pow274.6%
Applied egg-rr74.6%
Taylor expanded in k around 0 66.1%
if 9.19999999999999993e-14 < k Initial program 48.4%
Simplified48.4%
Taylor expanded in t around 0 77.9%
Taylor expanded in k around 0 63.6%
Final simplification65.5%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 9.2e-14) (/ 2.0 (* (* k_m 2.0) (* (sin k_m) (pow (/ t (pow (cbrt l) 2.0)) 3.0)))) (/ 2.0 (/ (* t (pow k_m 4.0)) (* (pow l 2.0) (cos k_m))))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / ((k_m * 2.0) * (sin(k_m) * pow((t / pow(cbrt(l), 2.0)), 3.0)));
} else {
tmp = 2.0 / ((t * pow(k_m, 4.0)) / (pow(l, 2.0) * cos(k_m)));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 9.2e-14) {
tmp = 2.0 / ((k_m * 2.0) * (Math.sin(k_m) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)));
} else {
tmp = 2.0 / ((t * Math.pow(k_m, 4.0)) / (Math.pow(l, 2.0) * Math.cos(k_m)));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 9.2e-14) tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * Float64(sin(k_m) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))); else tmp = Float64(2.0 / Float64(Float64(t * (k_m ^ 4.0)) / Float64((l ^ 2.0) * cos(k_m)))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 9.2e-14], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 9.2 \cdot 10^{-14}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot \left(\sin k\_m \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t \cdot {k\_m}^{4}}{{\ell}^{2} \cdot \cos k\_m}}\\
\end{array}
\end{array}
if k < 9.19999999999999993e-14Initial program 56.1%
Simplified56.1%
add-cube-cbrt56.0%
pow356.0%
cbrt-div55.9%
rem-cbrt-cube65.2%
cbrt-prod74.6%
pow274.6%
Applied egg-rr74.6%
Taylor expanded in k around 0 66.1%
if 9.19999999999999993e-14 < k Initial program 48.4%
Simplified48.4%
Taylor expanded in t around 0 77.9%
Taylor expanded in k around 0 61.8%
Final simplification65.1%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (* (sin k_m) (/ (pow t 3.0) (* l l)))))
(if (<= t 1.45e-75)
(pow (* l (sqrt (/ (/ 2.0 t) (pow k_m 4.0)))) 2.0)
(if (<= t 5.3e+101)
(/ 2.0 (* t_1 (* (tan k_m) (+ 1.0 (+ 1.0 (/ k_m (* t (/ t k_m))))))))
(if (<= t 3.2e+159)
(/ 2.0 (* (* 2.0 (pow k_m 2.0)) (/ (pow (/ t (cbrt l)) 3.0) l)))
(/ 2.0 (* (* k_m 2.0) t_1)))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = sin(k_m) * (pow(t, 3.0) / (l * l));
double tmp;
if (t <= 1.45e-75) {
tmp = pow((l * sqrt(((2.0 / t) / pow(k_m, 4.0)))), 2.0);
} else if (t <= 5.3e+101) {
tmp = 2.0 / (t_1 * (tan(k_m) * (1.0 + (1.0 + (k_m / (t * (t / k_m)))))));
} else if (t <= 3.2e+159) {
tmp = 2.0 / ((2.0 * pow(k_m, 2.0)) * (pow((t / cbrt(l)), 3.0) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * t_1);
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = Math.sin(k_m) * (Math.pow(t, 3.0) / (l * l));
double tmp;
if (t <= 1.45e-75) {
tmp = Math.pow((l * Math.sqrt(((2.0 / t) / Math.pow(k_m, 4.0)))), 2.0);
} else if (t <= 5.3e+101) {
tmp = 2.0 / (t_1 * (Math.tan(k_m) * (1.0 + (1.0 + (k_m / (t * (t / k_m)))))));
} else if (t <= 3.2e+159) {
tmp = 2.0 / ((2.0 * Math.pow(k_m, 2.0)) * (Math.pow((t / Math.cbrt(l)), 3.0) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * t_1);
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(sin(k_m) * Float64((t ^ 3.0) / Float64(l * l))) tmp = 0.0 if (t <= 1.45e-75) tmp = Float64(l * sqrt(Float64(Float64(2.0 / t) / (k_m ^ 4.0)))) ^ 2.0; elseif (t <= 5.3e+101) tmp = Float64(2.0 / Float64(t_1 * Float64(tan(k_m) * Float64(1.0 + Float64(1.0 + Float64(k_m / Float64(t * Float64(t / k_m)))))))); elseif (t <= 3.2e+159) tmp = Float64(2.0 / Float64(Float64(2.0 * (k_m ^ 2.0)) * Float64((Float64(t / cbrt(l)) ^ 3.0) / l))); else tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * t_1)); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 1.45e-75], N[Power[N[(l * N[Sqrt[N[(N[(2.0 / t), $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 5.3e+101], N[(2.0 / N[(t$95$1 * N[(N[Tan[k$95$m], $MachinePrecision] * N[(1.0 + N[(1.0 + N[(k$95$m / N[(t * N[(t / k$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.2e+159], N[(2.0 / N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \sin k\_m \cdot \frac{{t}^{3}}{\ell \cdot \ell}\\
\mathbf{if}\;t \leq 1.45 \cdot 10^{-75}:\\
\;\;\;\;{\left(\ell \cdot \sqrt{\frac{\frac{2}{t}}{{k\_m}^{4}}}\right)}^{2}\\
\mathbf{elif}\;t \leq 5.3 \cdot 10^{+101}:\\
\;\;\;\;\frac{2}{t\_1 \cdot \left(\tan k\_m \cdot \left(1 + \left(1 + \frac{k\_m}{t \cdot \frac{t}{k\_m}}\right)\right)\right)}\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{+159}:\\
\;\;\;\;\frac{2}{\left(2 \cdot {k\_m}^{2}\right) \cdot \frac{{\left(\frac{t}{\sqrt[3]{\ell}}\right)}^{3}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot t\_1}\\
\end{array}
\end{array}
if t < 1.4500000000000001e-75Initial program 47.1%
Simplified44.8%
Taylor expanded in k around 0 42.9%
associate-*r/42.9%
*-commutative42.9%
*-commutative42.9%
times-frac42.3%
Simplified42.3%
Taylor expanded in t around 0 51.7%
associate-*r/51.7%
*-commutative51.7%
associate-/l*51.7%
*-commutative51.7%
Simplified51.7%
add-sqr-sqrt34.8%
pow234.8%
sqrt-prod31.6%
sqrt-pow135.1%
metadata-eval35.1%
pow135.1%
associate-/r*35.1%
Applied egg-rr35.1%
if 1.4500000000000001e-75 < t < 5.30000000000000006e101Initial program 74.0%
Simplified73.9%
unpow273.9%
clear-num73.9%
frac-times74.0%
*-un-lft-identity74.0%
Applied egg-rr74.0%
if 5.30000000000000006e101 < t < 3.19999999999999985e159Initial program 51.7%
Simplified51.6%
Taylor expanded in k around 0 51.6%
add-cube-cbrt51.6%
pow351.6%
cbrt-div51.6%
rem-cbrt-cube80.0%
Applied egg-rr80.0%
if 3.19999999999999985e159 < t Initial program 80.7%
Simplified80.7%
Taylor expanded in k around 0 80.7%
Final simplification46.7%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= t 3.65e-96)
(pow (* l (sqrt (/ (/ 2.0 t) (pow k_m 4.0)))) 2.0)
(if (<= t 5.3e+101)
(/
2.0
(*
(/ (/ (pow t 3.0) l) l)
(* (* (sin k_m) (tan k_m)) (+ 2.0 (/ (/ k_m t) (/ t k_m))))))
(if (<= t 3.5e+159)
(/ 2.0 (* (* 2.0 (pow k_m 2.0)) (/ (pow (/ t (cbrt l)) 3.0) l)))
(/ 2.0 (* (* k_m 2.0) (* (sin k_m) (/ (pow t 3.0) (* l l)))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (t <= 3.65e-96) {
tmp = pow((l * sqrt(((2.0 / t) / pow(k_m, 4.0)))), 2.0);
} else if (t <= 5.3e+101) {
tmp = 2.0 / (((pow(t, 3.0) / l) / l) * ((sin(k_m) * tan(k_m)) * (2.0 + ((k_m / t) / (t / k_m)))));
} else if (t <= 3.5e+159) {
tmp = 2.0 / ((2.0 * pow(k_m, 2.0)) * (pow((t / cbrt(l)), 3.0) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * (sin(k_m) * (pow(t, 3.0) / (l * l))));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (t <= 3.65e-96) {
tmp = Math.pow((l * Math.sqrt(((2.0 / t) / Math.pow(k_m, 4.0)))), 2.0);
} else if (t <= 5.3e+101) {
tmp = 2.0 / (((Math.pow(t, 3.0) / l) / l) * ((Math.sin(k_m) * Math.tan(k_m)) * (2.0 + ((k_m / t) / (t / k_m)))));
} else if (t <= 3.5e+159) {
tmp = 2.0 / ((2.0 * Math.pow(k_m, 2.0)) * (Math.pow((t / Math.cbrt(l)), 3.0) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * (Math.sin(k_m) * (Math.pow(t, 3.0) / (l * l))));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (t <= 3.65e-96) tmp = Float64(l * sqrt(Float64(Float64(2.0 / t) / (k_m ^ 4.0)))) ^ 2.0; elseif (t <= 5.3e+101) tmp = Float64(2.0 / Float64(Float64(Float64((t ^ 3.0) / l) / l) * Float64(Float64(sin(k_m) * tan(k_m)) * Float64(2.0 + Float64(Float64(k_m / t) / Float64(t / k_m)))))); elseif (t <= 3.5e+159) tmp = Float64(2.0 / Float64(Float64(2.0 * (k_m ^ 2.0)) * Float64((Float64(t / cbrt(l)) ^ 3.0) / l))); else tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * Float64(sin(k_m) * Float64((t ^ 3.0) / Float64(l * l))))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[t, 3.65e-96], N[Power[N[(l * N[Sqrt[N[(N[(2.0 / t), $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 5.3e+101], N[(2.0 / N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision] * N[(N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(2.0 + N[(N[(k$95$m / t), $MachinePrecision] / N[(t / k$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.5e+159], N[(2.0 / N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.65 \cdot 10^{-96}:\\
\;\;\;\;{\left(\ell \cdot \sqrt{\frac{\frac{2}{t}}{{k\_m}^{4}}}\right)}^{2}\\
\mathbf{elif}\;t \leq 5.3 \cdot 10^{+101}:\\
\;\;\;\;\frac{2}{\frac{\frac{{t}^{3}}{\ell}}{\ell} \cdot \left(\left(\sin k\_m \cdot \tan k\_m\right) \cdot \left(2 + \frac{\frac{k\_m}{t}}{\frac{t}{k\_m}}\right)\right)}\\
\mathbf{elif}\;t \leq 3.5 \cdot 10^{+159}:\\
\;\;\;\;\frac{2}{\left(2 \cdot {k\_m}^{2}\right) \cdot \frac{{\left(\frac{t}{\sqrt[3]{\ell}}\right)}^{3}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot \left(\sin k\_m \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)}\\
\end{array}
\end{array}
if t < 3.64999999999999997e-96Initial program 46.7%
Simplified44.3%
Taylor expanded in k around 0 42.8%
associate-*r/42.8%
*-commutative42.8%
*-commutative42.8%
times-frac42.2%
Simplified42.2%
Taylor expanded in t around 0 52.0%
associate-*r/52.0%
*-commutative52.0%
associate-/l*52.0%
*-commutative52.0%
Simplified52.0%
add-sqr-sqrt34.4%
pow234.4%
sqrt-prod31.1%
sqrt-pow134.2%
metadata-eval34.2%
pow134.2%
associate-/r*34.1%
Applied egg-rr34.1%
if 3.64999999999999997e-96 < t < 5.30000000000000006e101Initial program 70.8%
Simplified66.0%
unpow266.0%
clear-num66.0%
un-div-inv66.0%
Applied egg-rr66.0%
if 5.30000000000000006e101 < t < 3.4999999999999999e159Initial program 51.7%
Simplified51.6%
Taylor expanded in k around 0 51.6%
add-cube-cbrt51.6%
pow351.6%
cbrt-div51.6%
rem-cbrt-cube80.0%
Applied egg-rr80.0%
if 3.4999999999999999e159 < t Initial program 80.7%
Simplified80.7%
Taylor expanded in k around 0 80.7%
Final simplification46.0%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= t 1.05e-19)
(pow (* l (sqrt (/ (/ 2.0 t) (pow k_m 4.0)))) 2.0)
(if (<= t 3.9e+158)
(/ 2.0 (* (* 2.0 (pow k_m 2.0)) (/ (pow (/ t (cbrt l)) 3.0) l)))
(/ 2.0 (* (* k_m 2.0) (* (sin k_m) (/ (pow t 3.0) (* l l))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.05e-19) {
tmp = pow((l * sqrt(((2.0 / t) / pow(k_m, 4.0)))), 2.0);
} else if (t <= 3.9e+158) {
tmp = 2.0 / ((2.0 * pow(k_m, 2.0)) * (pow((t / cbrt(l)), 3.0) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * (sin(k_m) * (pow(t, 3.0) / (l * l))));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.05e-19) {
tmp = Math.pow((l * Math.sqrt(((2.0 / t) / Math.pow(k_m, 4.0)))), 2.0);
} else if (t <= 3.9e+158) {
tmp = 2.0 / ((2.0 * Math.pow(k_m, 2.0)) * (Math.pow((t / Math.cbrt(l)), 3.0) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * (Math.sin(k_m) * (Math.pow(t, 3.0) / (l * l))));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (t <= 1.05e-19) tmp = Float64(l * sqrt(Float64(Float64(2.0 / t) / (k_m ^ 4.0)))) ^ 2.0; elseif (t <= 3.9e+158) tmp = Float64(2.0 / Float64(Float64(2.0 * (k_m ^ 2.0)) * Float64((Float64(t / cbrt(l)) ^ 3.0) / l))); else tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * Float64(sin(k_m) * Float64((t ^ 3.0) / Float64(l * l))))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[t, 1.05e-19], N[Power[N[(l * N[Sqrt[N[(N[(2.0 / t), $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 3.9e+158], N[(2.0 / N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.05 \cdot 10^{-19}:\\
\;\;\;\;{\left(\ell \cdot \sqrt{\frac{\frac{2}{t}}{{k\_m}^{4}}}\right)}^{2}\\
\mathbf{elif}\;t \leq 3.9 \cdot 10^{+158}:\\
\;\;\;\;\frac{2}{\left(2 \cdot {k\_m}^{2}\right) \cdot \frac{{\left(\frac{t}{\sqrt[3]{\ell}}\right)}^{3}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot \left(\sin k\_m \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)}\\
\end{array}
\end{array}
if t < 1.0499999999999999e-19Initial program 48.0%
Simplified45.4%
Taylor expanded in k around 0 43.1%
associate-*r/43.1%
*-commutative43.1%
*-commutative43.1%
times-frac42.6%
Simplified42.6%
Taylor expanded in t around 0 51.5%
associate-*r/51.5%
*-commutative51.5%
associate-/l*51.5%
*-commutative51.5%
Simplified51.5%
add-sqr-sqrt35.5%
pow235.5%
sqrt-prod32.4%
sqrt-pow135.8%
metadata-eval35.8%
pow135.8%
associate-/r*35.8%
Applied egg-rr35.8%
if 1.0499999999999999e-19 < t < 3.9e158Initial program 69.9%
Simplified63.5%
Taylor expanded in k around 0 53.8%
add-cube-cbrt53.7%
pow353.7%
cbrt-div53.7%
rem-cbrt-cube63.5%
Applied egg-rr63.5%
if 3.9e158 < t Initial program 80.7%
Simplified80.7%
Taylor expanded in k around 0 80.7%
Final simplification44.2%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= t 1.05e-19)
(pow (* l (sqrt (/ (/ 2.0 t) (pow k_m 4.0)))) 2.0)
(if (<= t 3.6e+158)
(/ 2.0 (* (* 2.0 (pow k_m 2.0)) (/ (* (pow t 2.0) (* t (/ 1.0 l))) l)))
(/ 2.0 (* (* k_m 2.0) (* (sin k_m) (/ (pow t 3.0) (* l l))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.05e-19) {
tmp = pow((l * sqrt(((2.0 / t) / pow(k_m, 4.0)))), 2.0);
} else if (t <= 3.6e+158) {
tmp = 2.0 / ((2.0 * pow(k_m, 2.0)) * ((pow(t, 2.0) * (t * (1.0 / l))) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * (sin(k_m) * (pow(t, 3.0) / (l * l))));
}
return tmp;
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (t <= 1.05d-19) then
tmp = (l * sqrt(((2.0d0 / t) / (k_m ** 4.0d0)))) ** 2.0d0
else if (t <= 3.6d+158) then
tmp = 2.0d0 / ((2.0d0 * (k_m ** 2.0d0)) * (((t ** 2.0d0) * (t * (1.0d0 / l))) / l))
else
tmp = 2.0d0 / ((k_m * 2.0d0) * (sin(k_m) * ((t ** 3.0d0) / (l * l))))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.05e-19) {
tmp = Math.pow((l * Math.sqrt(((2.0 / t) / Math.pow(k_m, 4.0)))), 2.0);
} else if (t <= 3.6e+158) {
tmp = 2.0 / ((2.0 * Math.pow(k_m, 2.0)) * ((Math.pow(t, 2.0) * (t * (1.0 / l))) / l));
} else {
tmp = 2.0 / ((k_m * 2.0) * (Math.sin(k_m) * (Math.pow(t, 3.0) / (l * l))));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if t <= 1.05e-19: tmp = math.pow((l * math.sqrt(((2.0 / t) / math.pow(k_m, 4.0)))), 2.0) elif t <= 3.6e+158: tmp = 2.0 / ((2.0 * math.pow(k_m, 2.0)) * ((math.pow(t, 2.0) * (t * (1.0 / l))) / l)) else: tmp = 2.0 / ((k_m * 2.0) * (math.sin(k_m) * (math.pow(t, 3.0) / (l * l)))) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (t <= 1.05e-19) tmp = Float64(l * sqrt(Float64(Float64(2.0 / t) / (k_m ^ 4.0)))) ^ 2.0; elseif (t <= 3.6e+158) tmp = Float64(2.0 / Float64(Float64(2.0 * (k_m ^ 2.0)) * Float64(Float64((t ^ 2.0) * Float64(t * Float64(1.0 / l))) / l))); else tmp = Float64(2.0 / Float64(Float64(k_m * 2.0) * Float64(sin(k_m) * Float64((t ^ 3.0) / Float64(l * l))))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (t <= 1.05e-19) tmp = (l * sqrt(((2.0 / t) / (k_m ^ 4.0)))) ^ 2.0; elseif (t <= 3.6e+158) tmp = 2.0 / ((2.0 * (k_m ^ 2.0)) * (((t ^ 2.0) * (t * (1.0 / l))) / l)); else tmp = 2.0 / ((k_m * 2.0) * (sin(k_m) * ((t ^ 3.0) / (l * l)))); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[t, 1.05e-19], N[Power[N[(l * N[Sqrt[N[(N[(2.0 / t), $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 3.6e+158], N[(2.0 / N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] * N[(t * N[(1.0 / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(k$95$m * 2.0), $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.05 \cdot 10^{-19}:\\
\;\;\;\;{\left(\ell \cdot \sqrt{\frac{\frac{2}{t}}{{k\_m}^{4}}}\right)}^{2}\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{+158}:\\
\;\;\;\;\frac{2}{\left(2 \cdot {k\_m}^{2}\right) \cdot \frac{{t}^{2} \cdot \left(t \cdot \frac{1}{\ell}\right)}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(k\_m \cdot 2\right) \cdot \left(\sin k\_m \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)}\\
\end{array}
\end{array}
if t < 1.0499999999999999e-19Initial program 48.0%
Simplified45.4%
Taylor expanded in k around 0 43.1%
associate-*r/43.1%
*-commutative43.1%
*-commutative43.1%
times-frac42.6%
Simplified42.6%
Taylor expanded in t around 0 51.5%
associate-*r/51.5%
*-commutative51.5%
associate-/l*51.5%
*-commutative51.5%
Simplified51.5%
add-sqr-sqrt35.5%
pow235.5%
sqrt-prod32.4%
sqrt-pow135.8%
metadata-eval35.8%
pow135.8%
associate-/r*35.8%
Applied egg-rr35.8%
if 1.0499999999999999e-19 < t < 3.59999999999999988e158Initial program 69.9%
Simplified63.5%
Taylor expanded in k around 0 53.8%
div-inv53.8%
unpow353.8%
associate-*l*60.4%
pow260.4%
Applied egg-rr60.4%
if 3.59999999999999988e158 < t Initial program 80.7%
Simplified80.7%
Taylor expanded in k around 0 80.7%
Final simplification43.8%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 2.2e+23) (/ 2.0 (* (* 2.0 (pow k_m 2.0)) (/ (* (pow t 2.0) (* t (/ 1.0 l))) l))) (/ 2.0 (/ (* t (pow k_m 4.0)) (pow l 2.0)))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 2.2e+23) {
tmp = 2.0 / ((2.0 * pow(k_m, 2.0)) * ((pow(t, 2.0) * (t * (1.0 / l))) / l));
} else {
tmp = 2.0 / ((t * pow(k_m, 4.0)) / pow(l, 2.0));
}
return tmp;
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 2.2d+23) then
tmp = 2.0d0 / ((2.0d0 * (k_m ** 2.0d0)) * (((t ** 2.0d0) * (t * (1.0d0 / l))) / l))
else
tmp = 2.0d0 / ((t * (k_m ** 4.0d0)) / (l ** 2.0d0))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 2.2e+23) {
tmp = 2.0 / ((2.0 * Math.pow(k_m, 2.0)) * ((Math.pow(t, 2.0) * (t * (1.0 / l))) / l));
} else {
tmp = 2.0 / ((t * Math.pow(k_m, 4.0)) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if k_m <= 2.2e+23: tmp = 2.0 / ((2.0 * math.pow(k_m, 2.0)) * ((math.pow(t, 2.0) * (t * (1.0 / l))) / l)) else: tmp = 2.0 / ((t * math.pow(k_m, 4.0)) / math.pow(l, 2.0)) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 2.2e+23) tmp = Float64(2.0 / Float64(Float64(2.0 * (k_m ^ 2.0)) * Float64(Float64((t ^ 2.0) * Float64(t * Float64(1.0 / l))) / l))); else tmp = Float64(2.0 / Float64(Float64(t * (k_m ^ 4.0)) / (l ^ 2.0))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (k_m <= 2.2e+23) tmp = 2.0 / ((2.0 * (k_m ^ 2.0)) * (((t ^ 2.0) * (t * (1.0 / l))) / l)); else tmp = 2.0 / ((t * (k_m ^ 4.0)) / (l ^ 2.0)); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 2.2e+23], N[(2.0 / N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] * N[(t * N[(1.0 / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 2.2 \cdot 10^{+23}:\\
\;\;\;\;\frac{2}{\left(2 \cdot {k\_m}^{2}\right) \cdot \frac{{t}^{2} \cdot \left(t \cdot \frac{1}{\ell}\right)}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t \cdot {k\_m}^{4}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if k < 2.20000000000000008e23Initial program 55.7%
Simplified55.2%
Taylor expanded in k around 0 56.1%
div-inv56.1%
unpow356.1%
associate-*l*59.5%
pow259.5%
Applied egg-rr59.5%
if 2.20000000000000008e23 < k Initial program 49.2%
Simplified49.2%
Taylor expanded in t around 0 75.9%
Taylor expanded in k around 0 59.5%
Final simplification59.5%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 1.04e+24) (/ 2.0 (* (* 2.0 (pow k_m 2.0)) (/ (/ (pow t 3.0) l) l))) (/ 2.0 (/ (* t (pow k_m 4.0)) (pow l 2.0)))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 1.04e+24) {
tmp = 2.0 / ((2.0 * pow(k_m, 2.0)) * ((pow(t, 3.0) / l) / l));
} else {
tmp = 2.0 / ((t * pow(k_m, 4.0)) / pow(l, 2.0));
}
return tmp;
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 1.04d+24) then
tmp = 2.0d0 / ((2.0d0 * (k_m ** 2.0d0)) * (((t ** 3.0d0) / l) / l))
else
tmp = 2.0d0 / ((t * (k_m ** 4.0d0)) / (l ** 2.0d0))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 1.04e+24) {
tmp = 2.0 / ((2.0 * Math.pow(k_m, 2.0)) * ((Math.pow(t, 3.0) / l) / l));
} else {
tmp = 2.0 / ((t * Math.pow(k_m, 4.0)) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if k_m <= 1.04e+24: tmp = 2.0 / ((2.0 * math.pow(k_m, 2.0)) * ((math.pow(t, 3.0) / l) / l)) else: tmp = 2.0 / ((t * math.pow(k_m, 4.0)) / math.pow(l, 2.0)) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 1.04e+24) tmp = Float64(2.0 / Float64(Float64(2.0 * (k_m ^ 2.0)) * Float64(Float64((t ^ 3.0) / l) / l))); else tmp = Float64(2.0 / Float64(Float64(t * (k_m ^ 4.0)) / (l ^ 2.0))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (k_m <= 1.04e+24) tmp = 2.0 / ((2.0 * (k_m ^ 2.0)) * (((t ^ 3.0) / l) / l)); else tmp = 2.0 / ((t * (k_m ^ 4.0)) / (l ^ 2.0)); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 1.04e+24], N[(2.0 / N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 1.04 \cdot 10^{+24}:\\
\;\;\;\;\frac{2}{\left(2 \cdot {k\_m}^{2}\right) \cdot \frac{\frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t \cdot {k\_m}^{4}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if k < 1.03999999999999997e24Initial program 55.7%
Simplified55.2%
Taylor expanded in k around 0 56.1%
if 1.03999999999999997e24 < k Initial program 49.2%
Simplified49.2%
Taylor expanded in t around 0 75.9%
Taylor expanded in k around 0 59.5%
Final simplification56.8%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 7.5e+23) (/ 2.0 (* (/ (pow t 3.0) l) (/ (* 2.0 (pow k_m 2.0)) l))) (/ 2.0 (/ (* t (pow k_m 4.0)) (pow l 2.0)))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 7.5e+23) {
tmp = 2.0 / ((pow(t, 3.0) / l) * ((2.0 * pow(k_m, 2.0)) / l));
} else {
tmp = 2.0 / ((t * pow(k_m, 4.0)) / pow(l, 2.0));
}
return tmp;
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 7.5d+23) then
tmp = 2.0d0 / (((t ** 3.0d0) / l) * ((2.0d0 * (k_m ** 2.0d0)) / l))
else
tmp = 2.0d0 / ((t * (k_m ** 4.0d0)) / (l ** 2.0d0))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 7.5e+23) {
tmp = 2.0 / ((Math.pow(t, 3.0) / l) * ((2.0 * Math.pow(k_m, 2.0)) / l));
} else {
tmp = 2.0 / ((t * Math.pow(k_m, 4.0)) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if k_m <= 7.5e+23: tmp = 2.0 / ((math.pow(t, 3.0) / l) * ((2.0 * math.pow(k_m, 2.0)) / l)) else: tmp = 2.0 / ((t * math.pow(k_m, 4.0)) / math.pow(l, 2.0)) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 7.5e+23) tmp = Float64(2.0 / Float64(Float64((t ^ 3.0) / l) * Float64(Float64(2.0 * (k_m ^ 2.0)) / l))); else tmp = Float64(2.0 / Float64(Float64(t * (k_m ^ 4.0)) / (l ^ 2.0))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (k_m <= 7.5e+23) tmp = 2.0 / (((t ^ 3.0) / l) * ((2.0 * (k_m ^ 2.0)) / l)); else tmp = 2.0 / ((t * (k_m ^ 4.0)) / (l ^ 2.0)); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 7.5e+23], N[(2.0 / N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] * N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 7.5 \cdot 10^{+23}:\\
\;\;\;\;\frac{2}{\frac{{t}^{3}}{\ell} \cdot \frac{2 \cdot {k\_m}^{2}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t \cdot {k\_m}^{4}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if k < 7.49999999999999987e23Initial program 55.7%
Simplified55.2%
Taylor expanded in k around 0 56.1%
associate-*l/57.1%
Applied egg-rr57.1%
associate-/l*56.6%
Simplified56.6%
if 7.49999999999999987e23 < k Initial program 49.2%
Simplified49.2%
Taylor expanded in t around 0 75.9%
Taylor expanded in k around 0 59.5%
Final simplification57.2%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 2.45e+23) (/ 2.0 (/ (* (* 2.0 (pow k_m 2.0)) (/ (pow t 3.0) l)) l)) (/ 2.0 (/ (* t (pow k_m 4.0)) (pow l 2.0)))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 2.45e+23) {
tmp = 2.0 / (((2.0 * pow(k_m, 2.0)) * (pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 / ((t * pow(k_m, 4.0)) / pow(l, 2.0));
}
return tmp;
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 2.45d+23) then
tmp = 2.0d0 / (((2.0d0 * (k_m ** 2.0d0)) * ((t ** 3.0d0) / l)) / l)
else
tmp = 2.0d0 / ((t * (k_m ** 4.0d0)) / (l ** 2.0d0))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 2.45e+23) {
tmp = 2.0 / (((2.0 * Math.pow(k_m, 2.0)) * (Math.pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 / ((t * Math.pow(k_m, 4.0)) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if k_m <= 2.45e+23: tmp = 2.0 / (((2.0 * math.pow(k_m, 2.0)) * (math.pow(t, 3.0) / l)) / l) else: tmp = 2.0 / ((t * math.pow(k_m, 4.0)) / math.pow(l, 2.0)) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 2.45e+23) tmp = Float64(2.0 / Float64(Float64(Float64(2.0 * (k_m ^ 2.0)) * Float64((t ^ 3.0) / l)) / l)); else tmp = Float64(2.0 / Float64(Float64(t * (k_m ^ 4.0)) / (l ^ 2.0))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (k_m <= 2.45e+23) tmp = 2.0 / (((2.0 * (k_m ^ 2.0)) * ((t ^ 3.0) / l)) / l); else tmp = 2.0 / ((t * (k_m ^ 4.0)) / (l ^ 2.0)); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 2.45e+23], N[(2.0 / N[(N[(N[(2.0 * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 2.45 \cdot 10^{+23}:\\
\;\;\;\;\frac{2}{\frac{\left(2 \cdot {k\_m}^{2}\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t \cdot {k\_m}^{4}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if k < 2.4500000000000001e23Initial program 55.7%
Simplified55.2%
Taylor expanded in k around 0 56.1%
associate-*l/57.1%
Applied egg-rr57.1%
if 2.4500000000000001e23 < k Initial program 49.2%
Simplified49.2%
Taylor expanded in t around 0 75.9%
Taylor expanded in k around 0 59.5%
Final simplification57.6%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (* 2.0 (/ (pow l 2.0) (* t (pow k_m 4.0)))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
return 2.0 * (pow(l, 2.0) / (t * pow(k_m, 4.0)));
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = 2.0d0 * ((l ** 2.0d0) / (t * (k_m ** 4.0d0)))
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
return 2.0 * (Math.pow(l, 2.0) / (t * Math.pow(k_m, 4.0)));
}
k_m = math.fabs(k) def code(t, l, k_m): return 2.0 * (math.pow(l, 2.0) / (t * math.pow(k_m, 4.0)))
k_m = abs(k) function code(t, l, k_m) return Float64(2.0 * Float64((l ^ 2.0) / Float64(t * (k_m ^ 4.0)))) end
k_m = abs(k); function tmp = code(t, l, k_m) tmp = 2.0 * ((l ^ 2.0) / (t * (k_m ^ 4.0))); end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := N[(2.0 * N[(N[Power[l, 2.0], $MachinePrecision] / N[(t * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
2 \cdot \frac{{\ell}^{2}}{t \cdot {k\_m}^{4}}
\end{array}
Initial program 54.3%
Simplified50.7%
Taylor expanded in k around 0 47.9%
associate-*r/47.9%
*-commutative47.9%
*-commutative47.9%
times-frac47.4%
Simplified47.4%
Taylor expanded in t around 0 52.4%
Final simplification52.4%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (/ 2.0 (* (pow k_m 4.0) (/ t (pow l 2.0)))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
return 2.0 / (pow(k_m, 4.0) * (t / pow(l, 2.0)));
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = 2.0d0 / ((k_m ** 4.0d0) * (t / (l ** 2.0d0)))
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
return 2.0 / (Math.pow(k_m, 4.0) * (t / Math.pow(l, 2.0)));
}
k_m = math.fabs(k) def code(t, l, k_m): return 2.0 / (math.pow(k_m, 4.0) * (t / math.pow(l, 2.0)))
k_m = abs(k) function code(t, l, k_m) return Float64(2.0 / Float64((k_m ^ 4.0) * Float64(t / (l ^ 2.0)))) end
k_m = abs(k); function tmp = code(t, l, k_m) tmp = 2.0 / ((k_m ^ 4.0) * (t / (l ^ 2.0))); end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := N[(2.0 / N[(N[Power[k$95$m, 4.0], $MachinePrecision] * N[(t / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
\frac{2}{{k\_m}^{4} \cdot \frac{t}{{\ell}^{2}}}
\end{array}
Initial program 54.3%
Simplified54.3%
Taylor expanded in t around 0 61.4%
Taylor expanded in k around 0 52.4%
associate-/l*52.7%
Simplified52.7%
Final simplification52.7%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (/ (/ (* 2.0 (pow l 2.0)) t) (pow k_m 4.0)))
k_m = fabs(k);
double code(double t, double l, double k_m) {
return ((2.0 * pow(l, 2.0)) / t) / pow(k_m, 4.0);
}
k_m = abs(k)
real(8) function code(t, l, k_m)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = ((2.0d0 * (l ** 2.0d0)) / t) / (k_m ** 4.0d0)
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
return ((2.0 * Math.pow(l, 2.0)) / t) / Math.pow(k_m, 4.0);
}
k_m = math.fabs(k) def code(t, l, k_m): return ((2.0 * math.pow(l, 2.0)) / t) / math.pow(k_m, 4.0)
k_m = abs(k) function code(t, l, k_m) return Float64(Float64(Float64(2.0 * (l ^ 2.0)) / t) / (k_m ^ 4.0)) end
k_m = abs(k); function tmp = code(t, l, k_m) tmp = ((2.0 * (l ^ 2.0)) / t) / (k_m ^ 4.0); end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := N[(N[(N[(2.0 * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
\frac{\frac{2 \cdot {\ell}^{2}}{t}}{{k\_m}^{4}}
\end{array}
Initial program 54.3%
Simplified50.7%
Taylor expanded in k around 0 47.9%
associate-*r/47.9%
*-commutative47.9%
*-commutative47.9%
times-frac47.4%
Simplified47.4%
Taylor expanded in t around 0 52.4%
pow252.4%
associate-*r/52.4%
pow252.4%
*-commutative52.4%
Applied egg-rr52.4%
associate-/r*52.7%
Simplified52.7%
Final simplification52.7%
herbie shell --seed 2024082
(FPCore (t l k)
:name "Toniolo and Linder, Equation (10+)"
:precision binary64
(/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))