
(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 22 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}
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (cbrt l) 2.0)))
(if (<= (* l l) 1e-313)
(/
2.0
(*
(pow (* t (/ (cbrt k) t_1)) 3.0)
(* (tan k) (+ 1.0 (+ 1.0 (pow (/ k t) 2.0))))))
(if (<= (* l l) 2e+300)
(/
2.0
(*
t
(fma
(pow k 2.0)
(/ (pow (sin k) 2.0) (* (pow l 2.0) (cos k)))
(* (/ 2.0 (pow l 2.0)) (/ (pow (* t (sin k)) 2.0) (cos k))))))
(/
2.0
(*
(pow (* (/ t t_1) (expm1 (log1p (cbrt (sin k))))) 3.0)
(* 2.0 (/ (sin k) (cos k)))))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), 2.0);
double tmp;
if ((l * l) <= 1e-313) {
tmp = 2.0 / (pow((t * (cbrt(k) / t_1)), 3.0) * (tan(k) * (1.0 + (1.0 + pow((k / t), 2.0)))));
} else if ((l * l) <= 2e+300) {
tmp = 2.0 / (t * fma(pow(k, 2.0), (pow(sin(k), 2.0) / (pow(l, 2.0) * cos(k))), ((2.0 / pow(l, 2.0)) * (pow((t * sin(k)), 2.0) / cos(k)))));
} else {
tmp = 2.0 / (pow(((t / t_1) * expm1(log1p(cbrt(sin(k))))), 3.0) * (2.0 * (sin(k) / cos(k))));
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(l) ^ 2.0 tmp = 0.0 if (Float64(l * l) <= 1e-313) tmp = Float64(2.0 / Float64((Float64(t * Float64(cbrt(k) / t_1)) ^ 3.0) * Float64(tan(k) * Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0)))))); elseif (Float64(l * l) <= 2e+300) tmp = Float64(2.0 / Float64(t * fma((k ^ 2.0), Float64((sin(k) ^ 2.0) / Float64((l ^ 2.0) * cos(k))), Float64(Float64(2.0 / (l ^ 2.0)) * Float64((Float64(t * sin(k)) ^ 2.0) / cos(k)))))); else tmp = Float64(2.0 / Float64((Float64(Float64(t / t_1) * expm1(log1p(cbrt(sin(k))))) ^ 3.0) * Float64(2.0 * Float64(sin(k) / cos(k))))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(l * l), $MachinePrecision], 1e-313], N[(2.0 / N[(N[Power[N[(t * N[(N[Power[k, 1/3], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 2e+300], N[(2.0 / N[(t * N[(N[Power[k, 2.0], $MachinePrecision] * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(2.0 / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[(t / t$95$1), $MachinePrecision] * N[(Exp[N[Log[1 + N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * N[(N[Sin[k], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{2}\\
\mathbf{if}\;\ell \cdot \ell \leq 10^{-313}:\\
\;\;\;\;\frac{2}{{\left(t \cdot \frac{\sqrt[3]{k}}{t\_1}\right)}^{3} \cdot \left(\tan k \cdot \left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right)\right)}\\
\mathbf{elif}\;\ell \cdot \ell \leq 2 \cdot 10^{+300}:\\
\;\;\;\;\frac{2}{t \cdot \mathsf{fma}\left({k}^{2}, \frac{{\sin k}^{2}}{{\ell}^{2} \cdot \cos k}, \frac{2}{{\ell}^{2}} \cdot \frac{{\left(t \cdot \sin k\right)}^{2}}{\cos k}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{t}{t\_1} \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(\sqrt[3]{\sin k}\right)\right)\right)}^{3} \cdot \left(2 \cdot \frac{\sin k}{\cos k}\right)}\\
\end{array}
\end{array}
if (*.f64 l l) < 1.00000000001e-313Initial program 55.5%
Simplified55.5%
Taylor expanded in k around 0 56.6%
add-cube-cbrt56.6%
pow256.6%
cbrt-div56.6%
*-commutative56.6%
cbrt-prod56.6%
unpow356.6%
add-cbrt-cube56.6%
unpow256.6%
cbrt-prod56.6%
unpow256.6%
cbrt-div56.6%
*-commutative56.6%
cbrt-prod56.7%
unpow356.7%
add-cbrt-cube77.0%
unpow277.0%
cbrt-prod91.6%
unpow291.6%
Applied egg-rr91.6%
unpow291.6%
unpow391.5%
associate-/l*91.6%
Simplified91.6%
if 1.00000000001e-313 < (*.f64 l l) < 2.0000000000000001e300Initial program 62.6%
Simplified62.6%
add-cube-cbrt62.4%
pow362.4%
*-commutative62.4%
cbrt-prod62.4%
cbrt-div63.9%
rem-cbrt-cube71.3%
cbrt-prod71.1%
pow271.1%
Applied egg-rr71.1%
*-commutative71.1%
Simplified71.1%
expm1-log1p-u71.2%
expm1-undefine48.9%
Applied egg-rr48.9%
expm1-define71.2%
Simplified71.2%
Taylor expanded in t around 0 81.6%
+-commutative81.6%
associate-/l*81.6%
fma-define81.6%
associate-*r/81.6%
times-frac81.6%
Simplified87.4%
if 2.0000000000000001e300 < (*.f64 l l) Initial program 29.9%
Simplified29.9%
add-cube-cbrt29.9%
pow329.9%
*-commutative29.9%
cbrt-prod29.9%
cbrt-div29.9%
rem-cbrt-cube35.5%
cbrt-prod71.9%
pow271.9%
Applied egg-rr71.9%
*-commutative71.9%
Simplified71.9%
expm1-log1p-u72.0%
expm1-undefine49.0%
Applied egg-rr49.0%
expm1-define72.0%
Simplified72.0%
Taylor expanded in t around inf 80.6%
(FPCore (t l k)
:precision binary64
(if (<= t 8.8e-69)
(/ 2.0 (* (pow k 2.0) (* t (/ (pow (sin k) 2.0) (* (pow l 2.0) (cos k))))))
(/
2.0
(*
(pow (* (/ t (pow (cbrt l) 2.0)) (expm1 (log1p (cbrt (sin k))))) 3.0)
(* (tan k) (+ 2.0 (pow (/ k t) 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 8.8e-69) {
tmp = 2.0 / (pow(k, 2.0) * (t * (pow(sin(k), 2.0) / (pow(l, 2.0) * cos(k)))));
} else {
tmp = 2.0 / (pow(((t / pow(cbrt(l), 2.0)) * expm1(log1p(cbrt(sin(k))))), 3.0) * (tan(k) * (2.0 + pow((k / t), 2.0))));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 8.8e-69) {
tmp = 2.0 / (Math.pow(k, 2.0) * (t * (Math.pow(Math.sin(k), 2.0) / (Math.pow(l, 2.0) * Math.cos(k)))));
} else {
tmp = 2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.expm1(Math.log1p(Math.cbrt(Math.sin(k))))), 3.0) * (Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 8.8e-69) tmp = Float64(2.0 / Float64((k ^ 2.0) * Float64(t * Float64((sin(k) ^ 2.0) / Float64((l ^ 2.0) * cos(k)))))); else tmp = Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * expm1(log1p(cbrt(sin(k))))) ^ 3.0) * Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 8.8e-69], N[(2.0 / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(Exp[N[Log[1 + N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 8.8 \cdot 10^{-69}:\\
\;\;\;\;\frac{2}{{k}^{2} \cdot \left(t \cdot \frac{{\sin k}^{2}}{{\ell}^{2} \cdot \cos k}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(\sqrt[3]{\sin k}\right)\right)\right)}^{3} \cdot \left(\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\right)}\\
\end{array}
\end{array}
if t < 8.8000000000000001e-69Initial program 47.1%
Simplified47.1%
add-cube-cbrt47.1%
pow347.1%
*-commutative47.1%
cbrt-prod47.0%
cbrt-div47.5%
rem-cbrt-cube58.8%
cbrt-prod66.8%
pow266.8%
Applied egg-rr66.8%
*-commutative66.8%
Simplified66.8%
expm1-log1p-u66.8%
expm1-undefine48.4%
Applied egg-rr48.4%
expm1-define66.8%
Simplified66.8%
Taylor expanded in t around 0 67.3%
associate-/l*66.5%
associate-/l*67.1%
Simplified67.1%
if 8.8000000000000001e-69 < t Initial program 63.4%
Simplified63.4%
add-cube-cbrt63.2%
pow363.2%
*-commutative63.2%
cbrt-prod63.2%
cbrt-div65.2%
rem-cbrt-cube72.6%
cbrt-prod93.1%
pow293.1%
Applied egg-rr93.1%
*-commutative93.1%
Simplified93.1%
expm1-log1p-u93.2%
expm1-undefine56.0%
Applied egg-rr56.0%
expm1-define93.2%
Simplified93.2%
associate-+r+93.2%
metadata-eval93.2%
distribute-lft-in93.2%
Applied egg-rr93.2%
distribute-lft-in93.2%
Simplified93.2%
(FPCore (t l k)
:precision binary64
(if (<= t 6.6e-69)
(/ 2.0 (* (pow k 2.0) (* t (/ (pow (sin k) 2.0) (* (pow l 2.0) (cos k))))))
(/
2.0
(*
(* (tan k) (+ 1.0 (+ 1.0 (pow (/ k t) 2.0))))
(pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k))) 3.0)))))
double code(double t, double l, double k) {
double tmp;
if (t <= 6.6e-69) {
tmp = 2.0 / (pow(k, 2.0) * (t * (pow(sin(k), 2.0) / (pow(l, 2.0) * cos(k)))));
} else {
tmp = 2.0 / ((tan(k) * (1.0 + (1.0 + pow((k / t), 2.0)))) * pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))), 3.0));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 6.6e-69) {
tmp = 2.0 / (Math.pow(k, 2.0) * (t * (Math.pow(Math.sin(k), 2.0) / (Math.pow(l, 2.0) * Math.cos(k)))));
} else {
tmp = 2.0 / ((Math.tan(k) * (1.0 + (1.0 + Math.pow((k / t), 2.0)))) * Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k))), 3.0));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 6.6e-69) tmp = Float64(2.0 / Float64((k ^ 2.0) * Float64(t * Float64((sin(k) ^ 2.0) / Float64((l ^ 2.0) * cos(k)))))); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0)))) * (Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) ^ 3.0))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 6.6e-69], N[(2.0 / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $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], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 6.6 \cdot 10^{-69}:\\
\;\;\;\;\frac{2}{{k}^{2} \cdot \left(t \cdot \frac{{\sin k}^{2}}{{\ell}^{2} \cdot \cos k}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right)\right) \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right)}^{3}}\\
\end{array}
\end{array}
if t < 6.6000000000000001e-69Initial program 47.1%
Simplified47.1%
add-cube-cbrt47.1%
pow347.1%
*-commutative47.1%
cbrt-prod47.0%
cbrt-div47.5%
rem-cbrt-cube58.8%
cbrt-prod66.8%
pow266.8%
Applied egg-rr66.8%
*-commutative66.8%
Simplified66.8%
expm1-log1p-u66.8%
expm1-undefine48.4%
Applied egg-rr48.4%
expm1-define66.8%
Simplified66.8%
Taylor expanded in t around 0 67.3%
associate-/l*66.5%
associate-/l*67.1%
Simplified67.1%
if 6.6000000000000001e-69 < t Initial program 63.4%
Simplified63.4%
add-cube-cbrt63.2%
pow363.2%
*-commutative63.2%
cbrt-prod63.2%
cbrt-div65.2%
rem-cbrt-cube72.6%
cbrt-prod93.1%
pow293.1%
Applied egg-rr93.1%
*-commutative93.1%
Simplified93.1%
Final simplification75.6%
(FPCore (t l k)
:precision binary64
(if (<= t 7.6e-69)
(/ 2.0 (* (pow k 2.0) (* t (/ (pow (sin k) 2.0) (* (pow l 2.0) (cos k))))))
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t) 2.0)))
(pow (* t (* (cbrt (sin k)) (pow (cbrt l) -2.0))) 3.0)))))
double code(double t, double l, double k) {
double tmp;
if (t <= 7.6e-69) {
tmp = 2.0 / (pow(k, 2.0) * (t * (pow(sin(k), 2.0) / (pow(l, 2.0) * cos(k)))));
} else {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t), 2.0))) * pow((t * (cbrt(sin(k)) * pow(cbrt(l), -2.0))), 3.0));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 7.6e-69) {
tmp = 2.0 / (Math.pow(k, 2.0) * (t * (Math.pow(Math.sin(k), 2.0) / (Math.pow(l, 2.0) * Math.cos(k)))));
} else {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))) * Math.pow((t * (Math.cbrt(Math.sin(k)) * Math.pow(Math.cbrt(l), -2.0))), 3.0));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 7.6e-69) tmp = Float64(2.0 / Float64((k ^ 2.0) * Float64(t * Float64((sin(k) ^ 2.0) / Float64((l ^ 2.0) * cos(k)))))); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))) * (Float64(t * Float64(cbrt(sin(k)) * (cbrt(l) ^ -2.0))) ^ 3.0))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 7.6e-69], N[(2.0 / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[(t * N[(N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision] * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 7.6 \cdot 10^{-69}:\\
\;\;\;\;\frac{2}{{k}^{2} \cdot \left(t \cdot \frac{{\sin k}^{2}}{{\ell}^{2} \cdot \cos k}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot {\left(t \cdot \left(\sqrt[3]{\sin k} \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)\right)}^{3}}\\
\end{array}
\end{array}
if t < 7.5999999999999995e-69Initial program 47.1%
Simplified47.1%
add-cube-cbrt47.1%
pow347.1%
*-commutative47.1%
cbrt-prod47.0%
cbrt-div47.5%
rem-cbrt-cube58.8%
cbrt-prod66.8%
pow266.8%
Applied egg-rr66.8%
*-commutative66.8%
Simplified66.8%
expm1-log1p-u66.8%
expm1-undefine48.4%
Applied egg-rr48.4%
expm1-define66.8%
Simplified66.8%
Taylor expanded in t around 0 67.3%
associate-/l*66.5%
associate-/l*67.1%
Simplified67.1%
if 7.5999999999999995e-69 < t Initial program 63.4%
Simplified63.4%
add-cube-cbrt63.2%
pow363.2%
*-commutative63.2%
cbrt-prod63.2%
cbrt-div65.2%
rem-cbrt-cube72.6%
cbrt-prod93.1%
pow293.1%
Applied egg-rr93.1%
*-commutative93.1%
Simplified93.1%
expm1-log1p-u93.2%
expm1-undefine56.0%
Applied egg-rr56.0%
expm1-define93.2%
Simplified93.2%
associate-+r+93.2%
metadata-eval93.2%
distribute-lft-in93.2%
Applied egg-rr93.2%
distribute-lft-in93.2%
Simplified93.2%
expm1-log1p-u93.1%
pow193.1%
div-inv93.1%
pow-flip93.1%
metadata-eval93.1%
Applied egg-rr93.1%
unpow193.1%
associate-*l*93.0%
Simplified93.0%
Final simplification75.5%
(FPCore (t l k)
:precision binary64
(if (<= k 2.15e-7)
(/
2.0
(*
(pow (* t (/ (cbrt k) (pow (cbrt l) 2.0))) 3.0)
(* (tan k) (+ 1.0 (+ 1.0 (pow (/ k t) 2.0))))))
(*
2.0
(/ (* (pow l 2.0) (cos k)) (* (pow (sin k) 2.0) (* t (pow k 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 2.15e-7) {
tmp = 2.0 / (pow((t * (cbrt(k) / pow(cbrt(l), 2.0))), 3.0) * (tan(k) * (1.0 + (1.0 + pow((k / t), 2.0)))));
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k)) / (pow(sin(k), 2.0) * (t * pow(k, 2.0))));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (k <= 2.15e-7) {
tmp = 2.0 / (Math.pow((t * (Math.cbrt(k) / Math.pow(Math.cbrt(l), 2.0))), 3.0) * (Math.tan(k) * (1.0 + (1.0 + Math.pow((k / t), 2.0)))));
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k)) / (Math.pow(Math.sin(k), 2.0) * (t * Math.pow(k, 2.0))));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (k <= 2.15e-7) tmp = Float64(2.0 / Float64((Float64(t * Float64(cbrt(k) / (cbrt(l) ^ 2.0))) ^ 3.0) * Float64(tan(k) * Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0)))))); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k)) / Float64((sin(k) ^ 2.0) * Float64(t * (k ^ 2.0))))); end return tmp end
code[t_, l_, k_] := If[LessEqual[k, 2.15e-7], N[(2.0 / N[(N[Power[N[(t * N[(N[Power[k, 1/3], $MachinePrecision] / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] * N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 2.15 \cdot 10^{-7}:\\
\;\;\;\;\frac{2}{{\left(t \cdot \frac{\sqrt[3]{k}}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3} \cdot \left(\tan k \cdot \left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k}{{\sin k}^{2} \cdot \left(t \cdot {k}^{2}\right)}\\
\end{array}
\end{array}
if k < 2.1500000000000001e-7Initial program 55.0%
Simplified55.0%
Taylor expanded in k around 0 54.5%
add-cube-cbrt54.4%
pow254.4%
cbrt-div54.4%
*-commutative54.4%
cbrt-prod54.4%
unpow354.4%
add-cbrt-cube54.4%
unpow254.4%
cbrt-prod54.4%
unpow254.4%
cbrt-div54.4%
*-commutative54.4%
cbrt-prod54.8%
unpow354.8%
add-cbrt-cube63.9%
unpow263.9%
cbrt-prod75.7%
unpow275.7%
Applied egg-rr75.7%
unpow275.7%
unpow375.7%
associate-/l*75.7%
Simplified75.7%
if 2.1500000000000001e-7 < k Initial program 46.4%
Simplified45.1%
Taylor expanded in t around 0 76.7%
associate-*r*76.7%
Simplified76.7%
Final simplification76.0%
(FPCore (t l k)
:precision binary64
(if (<= t 8e-69)
(/ 2.0 (* (pow k 2.0) (* t (/ (pow (sin k) 2.0) (* (pow l 2.0) (cos k))))))
(/
2.0
(*
(* (tan k) (+ 1.0 (+ 1.0 (pow (/ k t) 2.0))))
(* (sin k) (pow (/ t (pow (cbrt l) 2.0)) 3.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 8e-69) {
tmp = 2.0 / (pow(k, 2.0) * (t * (pow(sin(k), 2.0) / (pow(l, 2.0) * cos(k)))));
} else {
tmp = 2.0 / ((tan(k) * (1.0 + (1.0 + pow((k / t), 2.0)))) * (sin(k) * pow((t / pow(cbrt(l), 2.0)), 3.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 8e-69) {
tmp = 2.0 / (Math.pow(k, 2.0) * (t * (Math.pow(Math.sin(k), 2.0) / (Math.pow(l, 2.0) * Math.cos(k)))));
} else {
tmp = 2.0 / ((Math.tan(k) * (1.0 + (1.0 + Math.pow((k / t), 2.0)))) * (Math.sin(k) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 8e-69) tmp = Float64(2.0 / Float64((k ^ 2.0) * Float64(t * Float64((sin(k) ^ 2.0) / Float64((l ^ 2.0) * cos(k)))))); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0)))) * Float64(sin(k) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 8e-69], N[(2.0 / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 8 \cdot 10^{-69}:\\
\;\;\;\;\frac{2}{{k}^{2} \cdot \left(t \cdot \frac{{\sin k}^{2}}{{\ell}^{2} \cdot \cos k}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right)\right) \cdot \left(\sin k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}\\
\end{array}
\end{array}
if t < 7.9999999999999997e-69Initial program 47.1%
Simplified47.1%
add-cube-cbrt47.1%
pow347.1%
*-commutative47.1%
cbrt-prod47.0%
cbrt-div47.5%
rem-cbrt-cube58.8%
cbrt-prod66.8%
pow266.8%
Applied egg-rr66.8%
*-commutative66.8%
Simplified66.8%
expm1-log1p-u66.8%
expm1-undefine48.4%
Applied egg-rr48.4%
expm1-define66.8%
Simplified66.8%
Taylor expanded in t around 0 67.3%
associate-/l*66.5%
associate-/l*67.1%
Simplified67.1%
if 7.9999999999999997e-69 < t Initial program 63.4%
Simplified63.4%
add-cube-cbrt63.3%
pow363.3%
cbrt-div63.2%
rem-cbrt-cube69.5%
cbrt-prod85.2%
pow285.2%
Applied egg-rr85.2%
Final simplification73.0%
(FPCore (t l k)
:precision binary64
(if (<= t 1.55e-144)
(pow (* l (/ (* (sqrt 2.0) (sqrt (/ (cos k) t))) (* k (sin k)))) 2.0)
(if (<= t 8.6e+137)
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t) 2.0)))
(* (sin k) (* (/ (pow t 2.0) l) (/ t l)))))
(/
2.0
(* (pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k))) 3.0) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 1.55e-144) {
tmp = pow((l * ((sqrt(2.0) * sqrt((cos(k) / t))) / (k * sin(k)))), 2.0);
} else if (t <= 8.6e+137) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t), 2.0))) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))), 3.0) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 1.55e-144) {
tmp = Math.pow((l * ((Math.sqrt(2.0) * Math.sqrt((Math.cos(k) / t))) / (k * Math.sin(k)))), 2.0);
} else if (t <= 8.6e+137) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k))), 3.0) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 1.55e-144) tmp = Float64(l * Float64(Float64(sqrt(2.0) * sqrt(Float64(cos(k) / t))) / Float64(k * sin(k)))) ^ 2.0; elseif (t <= 8.6e+137) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); else tmp = Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) ^ 3.0) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 1.55e-144], N[Power[N[(l * N[(N[(N[Sqrt[2.0], $MachinePrecision] * N[Sqrt[N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 8.6e+137], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.55 \cdot 10^{-144}:\\
\;\;\;\;{\left(\ell \cdot \frac{\sqrt{2} \cdot \sqrt{\frac{\cos k}{t}}}{k \cdot \sin k}\right)}^{2}\\
\mathbf{elif}\;t \leq 8.6 \cdot 10^{+137}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 1.55e-144Initial program 47.8%
Simplified43.5%
add-sqr-sqrt28.7%
Applied egg-rr26.1%
unpow226.1%
associate-/l*26.7%
associate-/r*26.7%
Simplified26.7%
Taylor expanded in t around 0 38.1%
associate-*l/38.2%
Simplified38.2%
if 1.55e-144 < t < 8.59999999999999929e137Initial program 54.3%
Simplified54.3%
unpow354.2%
times-frac73.0%
pow273.0%
Applied egg-rr73.0%
associate-+r+82.6%
metadata-eval82.6%
distribute-lft-in82.6%
Applied egg-rr73.0%
distribute-lft-in82.6%
Simplified73.0%
if 8.59999999999999929e137 < t Initial program 67.1%
Simplified67.1%
add-cube-cbrt67.1%
pow367.1%
*-commutative67.1%
cbrt-prod67.1%
cbrt-div67.1%
rem-cbrt-cube72.0%
cbrt-prod94.8%
pow294.8%
Applied egg-rr94.8%
*-commutative94.8%
Simplified94.8%
Taylor expanded in k around 0 87.0%
Final simplification53.2%
(FPCore (t l k)
:precision binary64
(if (<= k 3e-7)
(/ 2.0 (* (pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k))) 3.0) (* 2.0 k)))
(*
2.0
(/ (* (pow l 2.0) (cos k)) (* (pow (sin k) 2.0) (* t (pow k 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 3e-7) {
tmp = 2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))), 3.0) * (2.0 * k));
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k)) / (pow(sin(k), 2.0) * (t * pow(k, 2.0))));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (k <= 3e-7) {
tmp = 2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k))), 3.0) * (2.0 * k));
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k)) / (Math.pow(Math.sin(k), 2.0) * (t * Math.pow(k, 2.0))));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (k <= 3e-7) tmp = Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) ^ 3.0) * Float64(2.0 * k))); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k)) / Float64((sin(k) ^ 2.0) * Float64(t * (k ^ 2.0))))); end return tmp end
code[t_, l_, k_] := If[LessEqual[k, 3e-7], 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], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] * N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 3 \cdot 10^{-7}:\\
\;\;\;\;\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k}{{\sin k}^{2} \cdot \left(t \cdot {k}^{2}\right)}\\
\end{array}
\end{array}
if k < 2.9999999999999999e-7Initial program 55.0%
Simplified55.0%
add-cube-cbrt54.9%
pow354.9%
*-commutative54.9%
cbrt-prod54.9%
cbrt-div56.3%
rem-cbrt-cube64.4%
cbrt-prod78.1%
pow278.1%
Applied egg-rr78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in k around 0 72.5%
if 2.9999999999999999e-7 < k Initial program 46.4%
Simplified45.1%
Taylor expanded in t around 0 76.7%
associate-*r*76.7%
Simplified76.7%
Final simplification73.8%
(FPCore (t l k)
:precision binary64
(if (<= t 4.7e-144)
(pow (* l (/ (* (sqrt 2.0) (sqrt (/ (cos k) t))) (* k (sin k)))) 2.0)
(if (<= t 2.35e+138)
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t) 2.0)))
(* (sin k) (* (/ (pow t 2.0) l) (/ t l)))))
(/ 2.0 (* (pow (* t (/ (cbrt k) (pow (cbrt l) 2.0))) 3.0) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 4.7e-144) {
tmp = pow((l * ((sqrt(2.0) * sqrt((cos(k) / t))) / (k * sin(k)))), 2.0);
} else if (t <= 2.35e+138) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t), 2.0))) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (pow((t * (cbrt(k) / pow(cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 4.7e-144) {
tmp = Math.pow((l * ((Math.sqrt(2.0) * Math.sqrt((Math.cos(k) / t))) / (k * Math.sin(k)))), 2.0);
} else if (t <= 2.35e+138) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (Math.pow((t * (Math.cbrt(k) / Math.pow(Math.cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 4.7e-144) tmp = Float64(l * Float64(Float64(sqrt(2.0) * sqrt(Float64(cos(k) / t))) / Float64(k * sin(k)))) ^ 2.0; elseif (t <= 2.35e+138) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); else tmp = Float64(2.0 / Float64((Float64(t * Float64(cbrt(k) / (cbrt(l) ^ 2.0))) ^ 3.0) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 4.7e-144], N[Power[N[(l * N[(N[(N[Sqrt[2.0], $MachinePrecision] * N[Sqrt[N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 2.35e+138], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(t * N[(N[Power[k, 1/3], $MachinePrecision] / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 4.7 \cdot 10^{-144}:\\
\;\;\;\;{\left(\ell \cdot \frac{\sqrt{2} \cdot \sqrt{\frac{\cos k}{t}}}{k \cdot \sin k}\right)}^{2}\\
\mathbf{elif}\;t \leq 2.35 \cdot 10^{+138}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t \cdot \frac{\sqrt[3]{k}}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 4.7000000000000002e-144Initial program 47.8%
Simplified43.5%
add-sqr-sqrt28.7%
Applied egg-rr26.1%
unpow226.1%
associate-/l*26.7%
associate-/r*26.7%
Simplified26.7%
Taylor expanded in t around 0 38.1%
associate-*l/38.2%
Simplified38.2%
if 4.7000000000000002e-144 < t < 2.3499999999999999e138Initial program 54.3%
Simplified54.3%
unpow354.2%
times-frac73.0%
pow273.0%
Applied egg-rr73.0%
associate-+r+82.6%
metadata-eval82.6%
distribute-lft-in82.6%
Applied egg-rr73.0%
distribute-lft-in82.6%
Simplified73.0%
if 2.3499999999999999e138 < t Initial program 67.1%
Simplified67.1%
Taylor expanded in k around 0 67.1%
Taylor expanded in k around 0 67.1%
add-cube-cbrt67.1%
pow267.1%
cbrt-div67.1%
*-commutative67.1%
cbrt-prod67.1%
unpow367.1%
add-cbrt-cube67.1%
unpow267.1%
cbrt-prod67.1%
unpow267.1%
cbrt-div67.1%
*-commutative67.1%
cbrt-prod67.1%
unpow367.1%
add-cbrt-cube71.9%
unpow271.9%
cbrt-prod86.7%
unpow286.7%
Applied egg-rr86.7%
unpow286.7%
unpow386.7%
associate-/l*86.7%
Simplified86.7%
Final simplification53.1%
(FPCore (t l k)
:precision binary64
(if (<= t 6e-144)
(pow (* l (* (sqrt (/ (cos k) t)) (/ (sqrt 2.0) (* k (sin k))))) 2.0)
(if (<= t 2.35e+138)
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t) 2.0)))
(* (sin k) (* (/ (pow t 2.0) l) (/ t l)))))
(/ 2.0 (* (pow (* t (/ (cbrt k) (pow (cbrt l) 2.0))) 3.0) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 6e-144) {
tmp = pow((l * (sqrt((cos(k) / t)) * (sqrt(2.0) / (k * sin(k))))), 2.0);
} else if (t <= 2.35e+138) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t), 2.0))) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (pow((t * (cbrt(k) / pow(cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 6e-144) {
tmp = Math.pow((l * (Math.sqrt((Math.cos(k) / t)) * (Math.sqrt(2.0) / (k * Math.sin(k))))), 2.0);
} else if (t <= 2.35e+138) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (Math.pow((t * (Math.cbrt(k) / Math.pow(Math.cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 6e-144) tmp = Float64(l * Float64(sqrt(Float64(cos(k) / t)) * Float64(sqrt(2.0) / Float64(k * sin(k))))) ^ 2.0; elseif (t <= 2.35e+138) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); else tmp = Float64(2.0 / Float64((Float64(t * Float64(cbrt(k) / (cbrt(l) ^ 2.0))) ^ 3.0) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 6e-144], N[Power[N[(l * N[(N[Sqrt[N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t, 2.35e+138], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(t * N[(N[Power[k, 1/3], $MachinePrecision] / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 6 \cdot 10^{-144}:\\
\;\;\;\;{\left(\ell \cdot \left(\sqrt{\frac{\cos k}{t}} \cdot \frac{\sqrt{2}}{k \cdot \sin k}\right)\right)}^{2}\\
\mathbf{elif}\;t \leq 2.35 \cdot 10^{+138}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t \cdot \frac{\sqrt[3]{k}}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 5.9999999999999997e-144Initial program 47.8%
Simplified43.5%
add-sqr-sqrt28.7%
Applied egg-rr26.1%
unpow226.1%
associate-/l*26.7%
associate-/r*26.7%
Simplified26.7%
Taylor expanded in t around 0 38.1%
if 5.9999999999999997e-144 < t < 2.3499999999999999e138Initial program 54.3%
Simplified54.3%
unpow354.2%
times-frac73.0%
pow273.0%
Applied egg-rr73.0%
associate-+r+82.6%
metadata-eval82.6%
distribute-lft-in82.6%
Applied egg-rr73.0%
distribute-lft-in82.6%
Simplified73.0%
if 2.3499999999999999e138 < t Initial program 67.1%
Simplified67.1%
Taylor expanded in k around 0 67.1%
Taylor expanded in k around 0 67.1%
add-cube-cbrt67.1%
pow267.1%
cbrt-div67.1%
*-commutative67.1%
cbrt-prod67.1%
unpow367.1%
add-cbrt-cube67.1%
unpow267.1%
cbrt-prod67.1%
unpow267.1%
cbrt-div67.1%
*-commutative67.1%
cbrt-prod67.1%
unpow367.1%
add-cbrt-cube71.9%
unpow271.9%
cbrt-prod86.7%
unpow286.7%
Applied egg-rr86.7%
unpow286.7%
unpow386.7%
associate-/l*86.7%
Simplified86.7%
Final simplification53.1%
(FPCore (t l k)
:precision binary64
(if (<= t 2.1e-73)
(/ 2.0 (* (/ (* t k) (pow l 2.0)) (/ (pow k 3.0) (cos k))))
(if (<= t 2.35e+138)
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t) 2.0)))
(* (sin k) (* (/ (pow t 2.0) l) (/ t l)))))
(/ 2.0 (* (pow (* t (/ (cbrt k) (pow (cbrt l) 2.0))) 3.0) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 2.1e-73) {
tmp = 2.0 / (((t * k) / pow(l, 2.0)) * (pow(k, 3.0) / cos(k)));
} else if (t <= 2.35e+138) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t), 2.0))) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (pow((t * (cbrt(k) / pow(cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 2.1e-73) {
tmp = 2.0 / (((t * k) / Math.pow(l, 2.0)) * (Math.pow(k, 3.0) / Math.cos(k)));
} else if (t <= 2.35e+138) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
} else {
tmp = 2.0 / (Math.pow((t * (Math.cbrt(k) / Math.pow(Math.cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 2.1e-73) tmp = Float64(2.0 / Float64(Float64(Float64(t * k) / (l ^ 2.0)) * Float64((k ^ 3.0) / cos(k)))); elseif (t <= 2.35e+138) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); else tmp = Float64(2.0 / Float64((Float64(t * Float64(cbrt(k) / (cbrt(l) ^ 2.0))) ^ 3.0) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 2.1e-73], N[(2.0 / N[(N[(N[(t * k), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[k, 3.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.35e+138], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(t * N[(N[Power[k, 1/3], $MachinePrecision] / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 2.1 \cdot 10^{-73}:\\
\;\;\;\;\frac{2}{\frac{t \cdot k}{{\ell}^{2}} \cdot \frac{{k}^{3}}{\cos k}}\\
\mathbf{elif}\;t \leq 2.35 \cdot 10^{+138}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t \cdot \frac{\sqrt[3]{k}}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 2.0999999999999999e-73Initial program 47.3%
Simplified47.3%
Taylor expanded in k around 0 43.6%
Taylor expanded in k around inf 51.9%
*-commutative51.9%
times-frac53.0%
Simplified53.0%
Taylor expanded in k around 0 56.8%
if 2.0999999999999999e-73 < t < 2.3499999999999999e138Initial program 57.3%
Simplified57.3%
unpow357.3%
times-frac76.4%
pow276.4%
Applied egg-rr76.4%
associate-+r+87.3%
metadata-eval87.3%
distribute-lft-in87.3%
Applied egg-rr76.4%
distribute-lft-in87.3%
Simplified76.4%
if 2.3499999999999999e138 < t Initial program 67.1%
Simplified67.1%
Taylor expanded in k around 0 67.1%
Taylor expanded in k around 0 67.1%
add-cube-cbrt67.1%
pow267.1%
cbrt-div67.1%
*-commutative67.1%
cbrt-prod67.1%
unpow367.1%
add-cbrt-cube67.1%
unpow267.1%
cbrt-prod67.1%
unpow267.1%
cbrt-div67.1%
*-commutative67.1%
cbrt-prod67.1%
unpow367.1%
add-cbrt-cube71.9%
unpow271.9%
cbrt-prod86.7%
unpow286.7%
Applied egg-rr86.7%
unpow286.7%
unpow386.7%
associate-/l*86.7%
Simplified86.7%
Final simplification65.2%
(FPCore (t l k)
:precision binary64
(if (<= t 8.5e-87)
(/ 2.0 (* (/ (* t k) (pow l 2.0)) (/ (pow k 3.0) (cos k))))
(if (<= t 4.2e-27)
(/
2.0
(/
(* (/ (pow t 3.0) l) (* (+ 2.0 (pow (/ k t) 2.0)) (* (tan k) (sin k))))
l))
(/ 2.0 (* (pow (* t (/ (cbrt k) (pow (cbrt l) 2.0))) 3.0) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 8.5e-87) {
tmp = 2.0 / (((t * k) / pow(l, 2.0)) * (pow(k, 3.0) / cos(k)));
} else if (t <= 4.2e-27) {
tmp = 2.0 / (((pow(t, 3.0) / l) * ((2.0 + pow((k / t), 2.0)) * (tan(k) * sin(k)))) / l);
} else {
tmp = 2.0 / (pow((t * (cbrt(k) / pow(cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 8.5e-87) {
tmp = 2.0 / (((t * k) / Math.pow(l, 2.0)) * (Math.pow(k, 3.0) / Math.cos(k)));
} else if (t <= 4.2e-27) {
tmp = 2.0 / (((Math.pow(t, 3.0) / l) * ((2.0 + Math.pow((k / t), 2.0)) * (Math.tan(k) * Math.sin(k)))) / l);
} else {
tmp = 2.0 / (Math.pow((t * (Math.cbrt(k) / Math.pow(Math.cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 8.5e-87) tmp = Float64(2.0 / Float64(Float64(Float64(t * k) / (l ^ 2.0)) * Float64((k ^ 3.0) / cos(k)))); elseif (t <= 4.2e-27) tmp = Float64(2.0 / Float64(Float64(Float64((t ^ 3.0) / l) * Float64(Float64(2.0 + (Float64(k / t) ^ 2.0)) * Float64(tan(k) * sin(k)))) / l)); else tmp = Float64(2.0 / Float64((Float64(t * Float64(cbrt(k) / (cbrt(l) ^ 2.0))) ^ 3.0) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 8.5e-87], N[(2.0 / N[(N[(N[(t * k), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[k, 3.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.2e-27], N[(2.0 / N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] * N[(N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(t * N[(N[Power[k, 1/3], $MachinePrecision] / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 8.5 \cdot 10^{-87}:\\
\;\;\;\;\frac{2}{\frac{t \cdot k}{{\ell}^{2}} \cdot \frac{{k}^{3}}{\cos k}}\\
\mathbf{elif}\;t \leq 4.2 \cdot 10^{-27}:\\
\;\;\;\;\frac{2}{\frac{\frac{{t}^{3}}{\ell} \cdot \left(\left(2 + {\left(\frac{k}{t}\right)}^{2}\right) \cdot \left(\tan k \cdot \sin k\right)\right)}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t \cdot \frac{\sqrt[3]{k}}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 8.5000000000000001e-87Initial program 46.9%
Simplified46.9%
Taylor expanded in k around 0 43.2%
Taylor expanded in k around inf 51.7%
*-commutative51.7%
times-frac52.7%
Simplified52.7%
Taylor expanded in k around 0 56.6%
if 8.5000000000000001e-87 < t < 4.20000000000000031e-27Initial program 67.8%
Simplified67.8%
associate-*l*67.6%
associate-/r*67.6%
associate-+r+67.6%
metadata-eval67.6%
associate-*l*67.5%
associate-*l/74.1%
Applied egg-rr74.1%
if 4.20000000000000031e-27 < t Initial program 61.5%
Simplified61.5%
Taylor expanded in k around 0 62.4%
Taylor expanded in k around 0 62.5%
add-cube-cbrt62.4%
pow262.4%
cbrt-div62.4%
*-commutative62.4%
cbrt-prod62.4%
unpow362.4%
add-cbrt-cube62.4%
unpow262.4%
cbrt-prod62.5%
unpow262.5%
cbrt-div62.4%
*-commutative62.4%
cbrt-prod62.4%
unpow362.4%
add-cbrt-cube69.4%
unpow269.4%
cbrt-prod82.6%
unpow282.6%
Applied egg-rr82.7%
unpow282.6%
unpow382.6%
associate-/l*82.5%
Simplified82.6%
Final simplification65.1%
(FPCore (t l k)
:precision binary64
(if (<= t 7.5e-74)
(/ 2.0 (* (/ (* t k) (pow l 2.0)) (/ (pow k 3.0) (cos k))))
(if (<= t 9.78e-44)
(/
2.0
(*
(/ (/ (pow t 3.0) l) l)
(* (* (tan k) (sin k)) (+ 2.0 (* (/ k t) (/ k t))))))
(/ 2.0 (* (pow (* t (/ (cbrt k) (pow (cbrt l) 2.0))) 3.0) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 7.5e-74) {
tmp = 2.0 / (((t * k) / pow(l, 2.0)) * (pow(k, 3.0) / cos(k)));
} else if (t <= 9.78e-44) {
tmp = 2.0 / (((pow(t, 3.0) / l) / l) * ((tan(k) * sin(k)) * (2.0 + ((k / t) * (k / t)))));
} else {
tmp = 2.0 / (pow((t * (cbrt(k) / pow(cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 7.5e-74) {
tmp = 2.0 / (((t * k) / Math.pow(l, 2.0)) * (Math.pow(k, 3.0) / Math.cos(k)));
} else if (t <= 9.78e-44) {
tmp = 2.0 / (((Math.pow(t, 3.0) / l) / l) * ((Math.tan(k) * Math.sin(k)) * (2.0 + ((k / t) * (k / t)))));
} else {
tmp = 2.0 / (Math.pow((t * (Math.cbrt(k) / Math.pow(Math.cbrt(l), 2.0))), 3.0) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 7.5e-74) tmp = Float64(2.0 / Float64(Float64(Float64(t * k) / (l ^ 2.0)) * Float64((k ^ 3.0) / cos(k)))); elseif (t <= 9.78e-44) tmp = Float64(2.0 / Float64(Float64(Float64((t ^ 3.0) / l) / l) * Float64(Float64(tan(k) * sin(k)) * Float64(2.0 + Float64(Float64(k / t) * Float64(k / t)))))); else tmp = Float64(2.0 / Float64((Float64(t * Float64(cbrt(k) / (cbrt(l) ^ 2.0))) ^ 3.0) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 7.5e-74], N[(2.0 / N[(N[(N[(t * k), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[k, 3.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.78e-44], N[(2.0 / N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision] * N[(N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[(2.0 + N[(N[(k / t), $MachinePrecision] * N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(t * N[(N[Power[k, 1/3], $MachinePrecision] / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 7.5 \cdot 10^{-74}:\\
\;\;\;\;\frac{2}{\frac{t \cdot k}{{\ell}^{2}} \cdot \frac{{k}^{3}}{\cos k}}\\
\mathbf{elif}\;t \leq 9.78 \cdot 10^{-44}:\\
\;\;\;\;\frac{2}{\frac{\frac{{t}^{3}}{\ell}}{\ell} \cdot \left(\left(\tan k \cdot \sin k\right) \cdot \left(2 + \frac{k}{t} \cdot \frac{k}{t}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t \cdot \frac{\sqrt[3]{k}}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 7.5e-74Initial program 47.3%
Simplified47.3%
Taylor expanded in k around 0 43.6%
Taylor expanded in k around inf 51.9%
*-commutative51.9%
times-frac53.0%
Simplified53.0%
Taylor expanded in k around 0 56.8%
if 7.5e-74 < t < 9.77999999999999994e-44Initial program 61.8%
Simplified61.5%
unpow261.5%
Applied egg-rr61.5%
if 9.77999999999999994e-44 < t Initial program 62.5%
Simplified62.5%
Taylor expanded in k around 0 62.2%
Taylor expanded in k around 0 62.1%
add-cube-cbrt62.2%
pow262.2%
cbrt-div62.2%
*-commutative62.2%
cbrt-prod62.2%
unpow362.2%
add-cbrt-cube62.2%
unpow262.2%
cbrt-prod62.2%
unpow262.2%
cbrt-div62.2%
*-commutative62.2%
cbrt-prod62.2%
unpow362.2%
add-cbrt-cube69.0%
unpow269.0%
cbrt-prod81.8%
unpow281.8%
Applied egg-rr81.8%
unpow281.8%
unpow381.8%
associate-/l*81.8%
Simplified81.7%
Final simplification64.4%
(FPCore (t l k)
:precision binary64
(if (<= t 7e-74)
(/ 2.0 (* (/ (* t k) (pow l 2.0)) (/ (pow k 3.0) (cos k))))
(if (<= t 3.5e+43)
(/
2.0
(*
(/ (/ (pow t 3.0) l) l)
(* (* (tan k) (sin k)) (+ 2.0 (* (/ k t) (/ k t))))))
(/ 2.0 (* (* (sin k) (pow (/ t (pow (cbrt l) 2.0)) 3.0)) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 7e-74) {
tmp = 2.0 / (((t * k) / pow(l, 2.0)) * (pow(k, 3.0) / cos(k)));
} else if (t <= 3.5e+43) {
tmp = 2.0 / (((pow(t, 3.0) / l) / l) * ((tan(k) * sin(k)) * (2.0 + ((k / t) * (k / t)))));
} else {
tmp = 2.0 / ((sin(k) * pow((t / pow(cbrt(l), 2.0)), 3.0)) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= 7e-74) {
tmp = 2.0 / (((t * k) / Math.pow(l, 2.0)) * (Math.pow(k, 3.0) / Math.cos(k)));
} else if (t <= 3.5e+43) {
tmp = 2.0 / (((Math.pow(t, 3.0) / l) / l) * ((Math.tan(k) * Math.sin(k)) * (2.0 + ((k / t) * (k / t)))));
} else {
tmp = 2.0 / ((Math.sin(k) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= 7e-74) tmp = Float64(2.0 / Float64(Float64(Float64(t * k) / (l ^ 2.0)) * Float64((k ^ 3.0) / cos(k)))); elseif (t <= 3.5e+43) tmp = Float64(2.0 / Float64(Float64(Float64((t ^ 3.0) / l) / l) * Float64(Float64(tan(k) * sin(k)) * Float64(2.0 + Float64(Float64(k / t) * Float64(k / t)))))); else tmp = Float64(2.0 / Float64(Float64(sin(k) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, 7e-74], N[(2.0 / N[(N[(N[(t * k), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[k, 3.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.5e+43], N[(2.0 / N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision] * N[(N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[(2.0 + N[(N[(k / t), $MachinePrecision] * N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 7 \cdot 10^{-74}:\\
\;\;\;\;\frac{2}{\frac{t \cdot k}{{\ell}^{2}} \cdot \frac{{k}^{3}}{\cos k}}\\
\mathbf{elif}\;t \leq 3.5 \cdot 10^{+43}:\\
\;\;\;\;\frac{2}{\frac{\frac{{t}^{3}}{\ell}}{\ell} \cdot \left(\left(\tan k \cdot \sin k\right) \cdot \left(2 + \frac{k}{t} \cdot \frac{k}{t}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\sin k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right) \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 7.00000000000000029e-74Initial program 47.3%
Simplified47.3%
Taylor expanded in k around 0 43.6%
Taylor expanded in k around inf 51.9%
*-commutative51.9%
times-frac53.0%
Simplified53.0%
Taylor expanded in k around 0 56.8%
if 7.00000000000000029e-74 < t < 3.5000000000000001e43Initial program 66.5%
Simplified65.8%
unpow265.8%
Applied egg-rr65.8%
if 3.5000000000000001e43 < t Initial program 61.0%
Simplified61.0%
add-cube-cbrt61.0%
pow361.0%
cbrt-div61.0%
rem-cbrt-cube69.2%
cbrt-prod89.9%
pow289.9%
Applied egg-rr89.9%
Taylor expanded in k around 0 80.0%
Final simplification63.3%
(FPCore (t l k)
:precision binary64
(if (<= t 7e-74)
(/ 2.0 (* (/ (* t k) (pow l 2.0)) (/ (pow k 3.0) (cos k))))
(if (<= t 3.5e+43)
(/
2.0
(*
(/ (/ (pow t 3.0) l) l)
(* (* (tan k) (sin k)) (+ 2.0 (* (/ k t) (/ k t))))))
(/ 2.0 (* (* 2.0 k) (* (sin k) (* (/ (pow t 2.0) l) (/ t l))))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 7e-74) {
tmp = 2.0 / (((t * k) / pow(l, 2.0)) * (pow(k, 3.0) / cos(k)));
} else if (t <= 3.5e+43) {
tmp = 2.0 / (((pow(t, 3.0) / l) / l) * ((tan(k) * sin(k)) * (2.0 + ((k / t) * (k / t)))));
} else {
tmp = 2.0 / ((2.0 * k) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 7d-74) then
tmp = 2.0d0 / (((t * k) / (l ** 2.0d0)) * ((k ** 3.0d0) / cos(k)))
else if (t <= 3.5d+43) then
tmp = 2.0d0 / ((((t ** 3.0d0) / l) / l) * ((tan(k) * sin(k)) * (2.0d0 + ((k / t) * (k / t)))))
else
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * (((t ** 2.0d0) / l) * (t / l))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 7e-74) {
tmp = 2.0 / (((t * k) / Math.pow(l, 2.0)) * (Math.pow(k, 3.0) / Math.cos(k)));
} else if (t <= 3.5e+43) {
tmp = 2.0 / (((Math.pow(t, 3.0) / l) / l) * ((Math.tan(k) * Math.sin(k)) * (2.0 + ((k / t) * (k / t)))));
} else {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 7e-74: tmp = 2.0 / (((t * k) / math.pow(l, 2.0)) * (math.pow(k, 3.0) / math.cos(k))) elif t <= 3.5e+43: tmp = 2.0 / (((math.pow(t, 3.0) / l) / l) * ((math.tan(k) * math.sin(k)) * (2.0 + ((k / t) * (k / t))))) else: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * ((math.pow(t, 2.0) / l) * (t / l)))) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 7e-74) tmp = Float64(2.0 / Float64(Float64(Float64(t * k) / (l ^ 2.0)) * Float64((k ^ 3.0) / cos(k)))); elseif (t <= 3.5e+43) tmp = Float64(2.0 / Float64(Float64(Float64((t ^ 3.0) / l) / l) * Float64(Float64(tan(k) * sin(k)) * Float64(2.0 + Float64(Float64(k / t) * Float64(k / t)))))); else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 7e-74) tmp = 2.0 / (((t * k) / (l ^ 2.0)) * ((k ^ 3.0) / cos(k))); elseif (t <= 3.5e+43) tmp = 2.0 / ((((t ^ 3.0) / l) / l) * ((tan(k) * sin(k)) * (2.0 + ((k / t) * (k / t))))); else tmp = 2.0 / ((2.0 * k) * (sin(k) * (((t ^ 2.0) / l) * (t / l)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 7e-74], N[(2.0 / N[(N[(N[(t * k), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[k, 3.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.5e+43], N[(2.0 / N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision] * N[(N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[(2.0 + N[(N[(k / t), $MachinePrecision] * N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 7 \cdot 10^{-74}:\\
\;\;\;\;\frac{2}{\frac{t \cdot k}{{\ell}^{2}} \cdot \frac{{k}^{3}}{\cos k}}\\
\mathbf{elif}\;t \leq 3.5 \cdot 10^{+43}:\\
\;\;\;\;\frac{2}{\frac{\frac{{t}^{3}}{\ell}}{\ell} \cdot \left(\left(\tan k \cdot \sin k\right) \cdot \left(2 + \frac{k}{t} \cdot \frac{k}{t}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\end{array}
\end{array}
if t < 7.00000000000000029e-74Initial program 47.3%
Simplified47.3%
Taylor expanded in k around 0 43.6%
Taylor expanded in k around inf 51.9%
*-commutative51.9%
times-frac53.0%
Simplified53.0%
Taylor expanded in k around 0 56.8%
if 7.00000000000000029e-74 < t < 3.5000000000000001e43Initial program 66.5%
Simplified65.8%
unpow265.8%
Applied egg-rr65.8%
if 3.5000000000000001e43 < t Initial program 61.0%
Simplified61.0%
unpow361.0%
times-frac78.6%
pow278.6%
Applied egg-rr78.6%
Taylor expanded in k around 0 74.0%
Final simplification61.8%
(FPCore (t l k) :precision binary64 (if (<= t 3.1e-18) (/ 2.0 (* (/ (* t k) (pow l 2.0)) (/ (pow k 3.0) (cos k)))) (/ 2.0 (* (* 2.0 k) (* (sin k) (* (/ (pow t 2.0) l) (/ t l)))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 3.1e-18) {
tmp = 2.0 / (((t * k) / pow(l, 2.0)) * (pow(k, 3.0) / cos(k)));
} else {
tmp = 2.0 / ((2.0 * k) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 3.1d-18) then
tmp = 2.0d0 / (((t * k) / (l ** 2.0d0)) * ((k ** 3.0d0) / cos(k)))
else
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * (((t ** 2.0d0) / l) * (t / l))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 3.1e-18) {
tmp = 2.0 / (((t * k) / Math.pow(l, 2.0)) * (Math.pow(k, 3.0) / Math.cos(k)));
} else {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 3.1e-18: tmp = 2.0 / (((t * k) / math.pow(l, 2.0)) * (math.pow(k, 3.0) / math.cos(k))) else: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * ((math.pow(t, 2.0) / l) * (t / l)))) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 3.1e-18) tmp = Float64(2.0 / Float64(Float64(Float64(t * k) / (l ^ 2.0)) * Float64((k ^ 3.0) / cos(k)))); else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 3.1e-18) tmp = 2.0 / (((t * k) / (l ^ 2.0)) * ((k ^ 3.0) / cos(k))); else tmp = 2.0 / ((2.0 * k) * (sin(k) * (((t ^ 2.0) / l) * (t / l)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 3.1e-18], N[(2.0 / N[(N[(N[(t * k), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[k, 3.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.1 \cdot 10^{-18}:\\
\;\;\;\;\frac{2}{\frac{t \cdot k}{{\ell}^{2}} \cdot \frac{{k}^{3}}{\cos k}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\end{array}
\end{array}
if t < 3.10000000000000007e-18Initial program 49.2%
Simplified49.2%
Taylor expanded in k around 0 45.3%
Taylor expanded in k around inf 52.5%
*-commutative52.5%
times-frac53.5%
Simplified53.5%
Taylor expanded in k around 0 57.0%
if 3.10000000000000007e-18 < t Initial program 60.5%
Simplified60.5%
unpow360.5%
times-frac75.8%
pow275.8%
Applied egg-rr75.8%
Taylor expanded in k around 0 70.6%
Final simplification60.8%
(FPCore (t l k) :precision binary64 (if (<= t 1.85e-18) (/ 2.0 (* (/ (pow k 3.0) (cos k)) (* k (/ t (pow l 2.0))))) (/ 2.0 (* (* 2.0 k) (* (sin k) (* (/ (pow t 2.0) l) (/ t l)))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 1.85e-18) {
tmp = 2.0 / ((pow(k, 3.0) / cos(k)) * (k * (t / pow(l, 2.0))));
} else {
tmp = 2.0 / ((2.0 * k) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 1.85d-18) then
tmp = 2.0d0 / (((k ** 3.0d0) / cos(k)) * (k * (t / (l ** 2.0d0))))
else
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * (((t ** 2.0d0) / l) * (t / l))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 1.85e-18) {
tmp = 2.0 / ((Math.pow(k, 3.0) / Math.cos(k)) * (k * (t / Math.pow(l, 2.0))));
} else {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 1.85e-18: tmp = 2.0 / ((math.pow(k, 3.0) / math.cos(k)) * (k * (t / math.pow(l, 2.0)))) else: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * ((math.pow(t, 2.0) / l) * (t / l)))) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 1.85e-18) tmp = Float64(2.0 / Float64(Float64((k ^ 3.0) / cos(k)) * Float64(k * Float64(t / (l ^ 2.0))))); else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 1.85e-18) tmp = 2.0 / (((k ^ 3.0) / cos(k)) * (k * (t / (l ^ 2.0)))); else tmp = 2.0 / ((2.0 * k) * (sin(k) * (((t ^ 2.0) / l) * (t / l)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 1.85e-18], N[(2.0 / N[(N[(N[Power[k, 3.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision] * N[(k * N[(t / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.85 \cdot 10^{-18}:\\
\;\;\;\;\frac{2}{\frac{{k}^{3}}{\cos k} \cdot \left(k \cdot \frac{t}{{\ell}^{2}}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\end{array}
\end{array}
if t < 1.8500000000000002e-18Initial program 49.2%
Simplified49.2%
Taylor expanded in k around 0 45.3%
Taylor expanded in k around inf 52.5%
*-commutative52.5%
times-frac53.5%
Simplified53.5%
Taylor expanded in k around 0 57.0%
associate-/l*56.9%
Simplified56.9%
if 1.8500000000000002e-18 < t Initial program 60.5%
Simplified60.5%
unpow360.5%
times-frac75.8%
pow275.8%
Applied egg-rr75.8%
Taylor expanded in k around 0 70.6%
Final simplification60.7%
(FPCore (t l k) :precision binary64 (if (<= k 4.4e+73) (/ 2.0 (* (* 2.0 k) (* (sin k) (* (/ (pow t 2.0) l) (/ t l))))) (* (* (pow l 2.0) (pow k -4.0)) (/ 2.0 t))))
double code(double t, double l, double k) {
double tmp;
if (k <= 4.4e+73) {
tmp = 2.0 / ((2.0 * k) * (sin(k) * ((pow(t, 2.0) / l) * (t / l))));
} else {
tmp = (pow(l, 2.0) * pow(k, -4.0)) * (2.0 / t);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 4.4d+73) then
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * (((t ** 2.0d0) / l) * (t / l))))
else
tmp = ((l ** 2.0d0) * (k ** (-4.0d0))) * (2.0d0 / t)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 4.4e+73) {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l))));
} else {
tmp = (Math.pow(l, 2.0) * Math.pow(k, -4.0)) * (2.0 / t);
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 4.4e+73: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * ((math.pow(t, 2.0) / l) * (t / l)))) else: tmp = (math.pow(l, 2.0) * math.pow(k, -4.0)) * (2.0 / t) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 4.4e+73) tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l))))); else tmp = Float64(Float64((l ^ 2.0) * (k ^ -4.0)) * Float64(2.0 / t)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 4.4e+73) tmp = 2.0 / ((2.0 * k) * (sin(k) * (((t ^ 2.0) / l) * (t / l)))); else tmp = ((l ^ 2.0) * (k ^ -4.0)) * (2.0 / t); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 4.4e+73], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Power[k, -4.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 4.4 \cdot 10^{+73}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left({\ell}^{2} \cdot {k}^{-4}\right) \cdot \frac{2}{t}\\
\end{array}
\end{array}
if k < 4.4e73Initial program 54.5%
Simplified54.5%
unpow354.6%
times-frac64.7%
pow264.7%
Applied egg-rr64.7%
Taylor expanded in k around 0 60.9%
if 4.4e73 < k Initial program 45.0%
Simplified45.0%
Taylor expanded in k around 0 40.2%
Taylor expanded in k around inf 62.2%
*-commutative62.2%
times-frac62.0%
Simplified62.0%
Taylor expanded in k around 0 62.2%
associate-*r/62.2%
*-commutative62.2%
times-frac63.9%
Simplified63.9%
pow263.9%
div-inv63.9%
pow263.9%
pow-flip63.9%
metadata-eval63.9%
Applied egg-rr63.9%
Final simplification61.6%
(FPCore (t l k) :precision binary64 (if (<= t 1.7e-32) (/ (/ (* 2.0 (pow l 2.0)) (pow k 4.0)) t) (/ 2.0 (* (* 2.0 k) (/ (* k (pow t 3.0)) (pow l 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 1.7e-32) {
tmp = ((2.0 * pow(l, 2.0)) / pow(k, 4.0)) / t;
} else {
tmp = 2.0 / ((2.0 * k) * ((k * pow(t, 3.0)) / pow(l, 2.0)));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 1.7d-32) then
tmp = ((2.0d0 * (l ** 2.0d0)) / (k ** 4.0d0)) / t
else
tmp = 2.0d0 / ((2.0d0 * k) * ((k * (t ** 3.0d0)) / (l ** 2.0d0)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 1.7e-32) {
tmp = ((2.0 * Math.pow(l, 2.0)) / Math.pow(k, 4.0)) / t;
} else {
tmp = 2.0 / ((2.0 * k) * ((k * Math.pow(t, 3.0)) / Math.pow(l, 2.0)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 1.7e-32: tmp = ((2.0 * math.pow(l, 2.0)) / math.pow(k, 4.0)) / t else: tmp = 2.0 / ((2.0 * k) * ((k * math.pow(t, 3.0)) / math.pow(l, 2.0))) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 1.7e-32) tmp = Float64(Float64(Float64(2.0 * (l ^ 2.0)) / (k ^ 4.0)) / t); else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(Float64(k * (t ^ 3.0)) / (l ^ 2.0)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 1.7e-32) tmp = ((2.0 * (l ^ 2.0)) / (k ^ 4.0)) / t; else tmp = 2.0 / ((2.0 * k) * ((k * (t ^ 3.0)) / (l ^ 2.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 1.7e-32], N[(N[(N[(2.0 * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.7 \cdot 10^{-32}:\\
\;\;\;\;\frac{\frac{2 \cdot {\ell}^{2}}{{k}^{4}}}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \frac{k \cdot {t}^{3}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if t < 1.69999999999999989e-32Initial program 48.4%
Simplified48.4%
Taylor expanded in k around 0 44.4%
Taylor expanded in k around inf 51.7%
*-commutative51.7%
times-frac52.7%
Simplified52.7%
Taylor expanded in k around 0 51.0%
associate-*r/51.0%
*-commutative51.0%
times-frac52.7%
Simplified52.7%
Taylor expanded in l around 0 51.0%
associate-*r/51.0%
associate-/r*52.7%
Simplified52.7%
if 1.69999999999999989e-32 < t Initial program 62.1%
Simplified62.1%
Taylor expanded in k around 0 62.9%
Taylor expanded in k around 0 63.0%
Final simplification55.7%
(FPCore (t l k) :precision binary64 (if (<= t 2.05e-32) (/ (/ (* 2.0 (pow l 2.0)) (pow k 4.0)) t) (/ 2.0 (* (* k (pow t 3.0)) (/ (* 2.0 k) (pow l 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 2.05e-32) {
tmp = ((2.0 * pow(l, 2.0)) / pow(k, 4.0)) / t;
} else {
tmp = 2.0 / ((k * pow(t, 3.0)) * ((2.0 * k) / pow(l, 2.0)));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 2.05d-32) then
tmp = ((2.0d0 * (l ** 2.0d0)) / (k ** 4.0d0)) / t
else
tmp = 2.0d0 / ((k * (t ** 3.0d0)) * ((2.0d0 * k) / (l ** 2.0d0)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 2.05e-32) {
tmp = ((2.0 * Math.pow(l, 2.0)) / Math.pow(k, 4.0)) / t;
} else {
tmp = 2.0 / ((k * Math.pow(t, 3.0)) * ((2.0 * k) / Math.pow(l, 2.0)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 2.05e-32: tmp = ((2.0 * math.pow(l, 2.0)) / math.pow(k, 4.0)) / t else: tmp = 2.0 / ((k * math.pow(t, 3.0)) * ((2.0 * k) / math.pow(l, 2.0))) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 2.05e-32) tmp = Float64(Float64(Float64(2.0 * (l ^ 2.0)) / (k ^ 4.0)) / t); else tmp = Float64(2.0 / Float64(Float64(k * (t ^ 3.0)) * Float64(Float64(2.0 * k) / (l ^ 2.0)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 2.05e-32) tmp = ((2.0 * (l ^ 2.0)) / (k ^ 4.0)) / t; else tmp = 2.0 / ((k * (t ^ 3.0)) * ((2.0 * k) / (l ^ 2.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 2.05e-32], N[(N[(N[(2.0 * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision], N[(2.0 / N[(N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 * k), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 2.05 \cdot 10^{-32}:\\
\;\;\;\;\frac{\frac{2 \cdot {\ell}^{2}}{{k}^{4}}}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(k \cdot {t}^{3}\right) \cdot \frac{2 \cdot k}{{\ell}^{2}}}\\
\end{array}
\end{array}
if t < 2.04999999999999988e-32Initial program 48.4%
Simplified48.4%
Taylor expanded in k around 0 44.4%
Taylor expanded in k around inf 51.7%
*-commutative51.7%
times-frac52.7%
Simplified52.7%
Taylor expanded in k around 0 51.0%
associate-*r/51.0%
*-commutative51.0%
times-frac52.7%
Simplified52.7%
Taylor expanded in l around 0 51.0%
associate-*r/51.0%
associate-/r*52.7%
Simplified52.7%
if 2.04999999999999988e-32 < t Initial program 62.1%
Simplified62.1%
Taylor expanded in k around 0 62.9%
Taylor expanded in k around 0 63.0%
associate-*l/62.0%
Applied egg-rr62.0%
associate-/l*61.5%
*-commutative61.5%
Simplified61.5%
Final simplification55.3%
(FPCore (t l k) :precision binary64 (/ 2.0 (* (/ t (pow l 2.0)) (pow k 4.0))))
double code(double t, double l, double k) {
return 2.0 / ((t / pow(l, 2.0)) * pow(k, 4.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 / (l ** 2.0d0)) * (k ** 4.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((t / Math.pow(l, 2.0)) * Math.pow(k, 4.0));
}
def code(t, l, k): return 2.0 / ((t / math.pow(l, 2.0)) * math.pow(k, 4.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(t / (l ^ 2.0)) * (k ^ 4.0))) end
function tmp = code(t, l, k) tmp = 2.0 / ((t / (l ^ 2.0)) * (k ^ 4.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(t / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\frac{t}{{\ell}^{2}} \cdot {k}^{4}}
\end{array}
Initial program 52.4%
Simplified52.4%
Taylor expanded in k around 0 49.8%
Taylor expanded in k around inf 50.2%
*-commutative50.2%
times-frac50.9%
Simplified50.9%
Taylor expanded in k around 0 49.7%
associate-/l*51.2%
Simplified51.2%
Final simplification51.2%
(FPCore (t l k) :precision binary64 (* (pow k -4.0) (* (pow l 2.0) (/ 2.0 t))))
double code(double t, double l, double k) {
return pow(k, -4.0) * (pow(l, 2.0) * (2.0 / t));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (k ** (-4.0d0)) * ((l ** 2.0d0) * (2.0d0 / t))
end function
public static double code(double t, double l, double k) {
return Math.pow(k, -4.0) * (Math.pow(l, 2.0) * (2.0 / t));
}
def code(t, l, k): return math.pow(k, -4.0) * (math.pow(l, 2.0) * (2.0 / t))
function code(t, l, k) return Float64((k ^ -4.0) * Float64((l ^ 2.0) * Float64(2.0 / t))) end
function tmp = code(t, l, k) tmp = (k ^ -4.0) * ((l ^ 2.0) * (2.0 / t)); end
code[t_, l_, k_] := N[(N[Power[k, -4.0], $MachinePrecision] * N[(N[Power[l, 2.0], $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{k}^{-4} \cdot \left({\ell}^{2} \cdot \frac{2}{t}\right)
\end{array}
Initial program 52.4%
Simplified52.4%
Taylor expanded in k around 0 49.8%
Taylor expanded in k around inf 50.2%
*-commutative50.2%
times-frac50.9%
Simplified50.9%
Taylor expanded in k around 0 49.7%
associate-*r/49.7%
*-commutative49.7%
times-frac50.6%
Simplified50.6%
associate-*r/50.6%
pow250.6%
div-inv50.6%
pow250.6%
pow-flip50.6%
metadata-eval50.6%
Applied egg-rr50.6%
associate-/l*50.6%
*-commutative50.6%
associate-*r*50.8%
*-commutative50.8%
Simplified50.8%
Final simplification50.8%
herbie shell --seed 2024110
(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))))