
(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 17 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 (/ t (pow (cbrt l) 2.0)))
(t_2 (cbrt (hypot 1.0 (hypot 1.0 (/ k_m t))))))
(if (<= k_m 1e-152)
(/
2.0
(pow (* t_1 (* (cbrt 2.0) (* (cbrt (tan k_m)) (cbrt (sin k_m))))) 3.0))
(/
2.0
(pow (* t_1 (* (* t_2 t_2) (cbrt (* (tan k_m) (sin k_m))))) 3.0)))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = t / pow(cbrt(l), 2.0);
double t_2 = cbrt(hypot(1.0, hypot(1.0, (k_m / t))));
double tmp;
if (k_m <= 1e-152) {
tmp = 2.0 / pow((t_1 * (cbrt(2.0) * (cbrt(tan(k_m)) * cbrt(sin(k_m))))), 3.0);
} else {
tmp = 2.0 / pow((t_1 * ((t_2 * t_2) * cbrt((tan(k_m) * sin(k_m))))), 3.0);
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = t / Math.pow(Math.cbrt(l), 2.0);
double t_2 = Math.cbrt(Math.hypot(1.0, Math.hypot(1.0, (k_m / t))));
double tmp;
if (k_m <= 1e-152) {
tmp = 2.0 / Math.pow((t_1 * (Math.cbrt(2.0) * (Math.cbrt(Math.tan(k_m)) * Math.cbrt(Math.sin(k_m))))), 3.0);
} else {
tmp = 2.0 / Math.pow((t_1 * ((t_2 * t_2) * Math.cbrt((Math.tan(k_m) * Math.sin(k_m))))), 3.0);
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(t / (cbrt(l) ^ 2.0)) t_2 = cbrt(hypot(1.0, hypot(1.0, Float64(k_m / t)))) tmp = 0.0 if (k_m <= 1e-152) tmp = Float64(2.0 / (Float64(t_1 * Float64(cbrt(2.0) * Float64(cbrt(tan(k_m)) * cbrt(sin(k_m))))) ^ 3.0)); else tmp = Float64(2.0 / (Float64(t_1 * Float64(Float64(t_2 * t_2) * cbrt(Float64(tan(k_m) * sin(k_m))))) ^ 3.0)); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[Sqrt[1.0 ^ 2 + N[Sqrt[1.0 ^ 2 + N[(k$95$m / t), $MachinePrecision] ^ 2], $MachinePrecision] ^ 2], $MachinePrecision], 1/3], $MachinePrecision]}, If[LessEqual[k$95$m, 1e-152], N[(2.0 / N[Power[N[(t$95$1 * N[(N[Power[2.0, 1/3], $MachinePrecision] * N[(N[Power[N[Tan[k$95$m], $MachinePrecision], 1/3], $MachinePrecision] * N[Power[N[Sin[k$95$m], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[Power[N[(t$95$1 * N[(N[(t$95$2 * t$95$2), $MachinePrecision] * N[Power[N[(N[Tan[k$95$m], $MachinePrecision] * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
t_2 := \sqrt[3]{\mathsf{hypot}\left(1, \mathsf{hypot}\left(1, \frac{k\_m}{t}\right)\right)}\\
\mathbf{if}\;k\_m \leq 10^{-152}:\\
\;\;\;\;\frac{2}{{\left(t\_1 \cdot \left(\sqrt[3]{2} \cdot \left(\sqrt[3]{\tan k\_m} \cdot \sqrt[3]{\sin k\_m}\right)\right)\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t\_1 \cdot \left(\left(t\_2 \cdot t\_2\right) \cdot \sqrt[3]{\tan k\_m \cdot \sin k\_m}\right)\right)}^{3}}\\
\end{array}
\end{array}
if k < 1.00000000000000007e-152Initial program 62.0%
+-commutative62.0%
associate-+r+62.0%
metadata-eval62.0%
associate-*l*55.3%
associate-/r*59.4%
add-cube-cbrt59.4%
pow359.4%
Applied egg-rr71.3%
*-commutative71.3%
cbrt-prod71.3%
Applied egg-rr71.3%
Taylor expanded in k around 0 60.8%
*-commutative60.8%
cbrt-prod77.5%
Applied egg-rr77.5%
if 1.00000000000000007e-152 < k Initial program 55.7%
+-commutative55.7%
associate-+r+55.7%
metadata-eval55.7%
associate-*l*55.7%
associate-/r*57.2%
add-cube-cbrt57.1%
pow357.1%
Applied egg-rr75.1%
*-commutative75.1%
cbrt-prod75.1%
Applied egg-rr75.1%
pow1/374.4%
add-sqr-sqrt74.4%
unpow-prod-down74.4%
Applied egg-rr74.4%
unpow1/374.6%
unpow1/375.0%
Simplified92.2%
Final simplification81.8%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (/ (cbrt (/ 2.0 (sin k_m))) (/ t (pow (cbrt l) 2.0)))))
(if (<= t 1.45e-84)
(* (/ l (tan k_m)) (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(* (/ (pow t_1 2.0) (+ 2.0 (pow (/ k_m t) 2.0))) (/ t_1 (tan k_m))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = cbrt((2.0 / sin(k_m))) / (t / pow(cbrt(l), 2.0));
double tmp;
if (t <= 1.45e-84) {
tmp = (l / tan(k_m)) * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else {
tmp = (pow(t_1, 2.0) / (2.0 + pow((k_m / t), 2.0))) * (t_1 / tan(k_m));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = Math.cbrt((2.0 / Math.sin(k_m))) / (t / Math.pow(Math.cbrt(l), 2.0));
double tmp;
if (t <= 1.45e-84) {
tmp = (l / Math.tan(k_m)) * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else {
tmp = (Math.pow(t_1, 2.0) / (2.0 + Math.pow((k_m / t), 2.0))) * (t_1 / Math.tan(k_m));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(cbrt(Float64(2.0 / sin(k_m))) / Float64(t / (cbrt(l) ^ 2.0))) tmp = 0.0 if (t <= 1.45e-84) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); else tmp = Float64(Float64((t_1 ^ 2.0) / Float64(2.0 + (Float64(k_m / t) ^ 2.0))) * Float64(t_1 / tan(k_m))); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(N[Power[N[(2.0 / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 1.45e-84], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[t$95$1, 2.0], $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{\sqrt[3]{\frac{2}{\sin k\_m}}}{\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}}\\
\mathbf{if}\;t \leq 1.45 \cdot 10^{-84}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{t\_1}^{2}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}} \cdot \frac{t\_1}{\tan k\_m}\\
\end{array}
\end{array}
if t < 1.4500000000000001e-84Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 1.4500000000000001e-84 < t Initial program 64.4%
Simplified68.4%
associate-/l/68.4%
add-cube-cbrt68.3%
times-frac68.4%
Applied egg-rr95.0%
Final simplification82.0%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (pow (/ k_m t) 2.0)))
(if (<=
(/
2.0
(*
(+ 1.0 (+ 1.0 t_1))
(* (tan k_m) (* (sin k_m) (/ (pow t 3.0) (* l l))))))
1e+270)
(/
(/ (* l (* (/ 2.0 (sin k_m)) (/ l (pow t 3.0)))) (tan k_m))
(+ 2.0 t_1))
(* (/ l (tan k_m)) (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = pow((k_m / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (1.0 + t_1)) * (tan(k_m) * (sin(k_m) * (pow(t, 3.0) / (l * l)))))) <= 1e+270) {
tmp = ((l * ((2.0 / sin(k_m)) * (l / pow(t, 3.0)))) / tan(k_m)) / (2.0 + t_1);
} else {
tmp = (l / tan(k_m)) * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
}
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) :: t_1
real(8) :: tmp
t_1 = (k_m / t) ** 2.0d0
if ((2.0d0 / ((1.0d0 + (1.0d0 + t_1)) * (tan(k_m) * (sin(k_m) * ((t ** 3.0d0) / (l * l)))))) <= 1d+270) then
tmp = ((l * ((2.0d0 / sin(k_m)) * (l / (t ** 3.0d0)))) / tan(k_m)) / (2.0d0 + t_1)
else
tmp = (l / tan(k_m)) * ((l / (k_m ** 2.0d0)) * (2.0d0 / (t * sin(k_m))))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = Math.pow((k_m / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (1.0 + t_1)) * (Math.tan(k_m) * (Math.sin(k_m) * (Math.pow(t, 3.0) / (l * l)))))) <= 1e+270) {
tmp = ((l * ((2.0 / Math.sin(k_m)) * (l / Math.pow(t, 3.0)))) / Math.tan(k_m)) / (2.0 + t_1);
} else {
tmp = (l / Math.tan(k_m)) * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): t_1 = math.pow((k_m / t), 2.0) tmp = 0 if (2.0 / ((1.0 + (1.0 + t_1)) * (math.tan(k_m) * (math.sin(k_m) * (math.pow(t, 3.0) / (l * l)))))) <= 1e+270: tmp = ((l * ((2.0 / math.sin(k_m)) * (l / math.pow(t, 3.0)))) / math.tan(k_m)) / (2.0 + t_1) else: tmp = (l / math.tan(k_m)) * ((l / math.pow(k_m, 2.0)) * (2.0 / (t * math.sin(k_m)))) return tmp
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(k_m / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(1.0 + Float64(1.0 + t_1)) * Float64(tan(k_m) * Float64(sin(k_m) * Float64((t ^ 3.0) / Float64(l * l)))))) <= 1e+270) tmp = Float64(Float64(Float64(l * Float64(Float64(2.0 / sin(k_m)) * Float64(l / (t ^ 3.0)))) / tan(k_m)) / Float64(2.0 + t_1)); else tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) t_1 = (k_m / t) ^ 2.0; tmp = 0.0; if ((2.0 / ((1.0 + (1.0 + t_1)) * (tan(k_m) * (sin(k_m) * ((t ^ 3.0) / (l * l)))))) <= 1e+270) tmp = ((l * ((2.0 / sin(k_m)) * (l / (t ^ 3.0)))) / tan(k_m)) / (2.0 + t_1); else tmp = (l / tan(k_m)) * ((l / (k_m ^ 2.0)) * (2.0 / (t * sin(k_m)))); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(1.0 + N[(1.0 + t$95$1), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+270], N[(N[(N[(l * N[(N[(2.0 / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := {\left(\frac{k\_m}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(1 + \left(1 + t\_1\right)\right) \cdot \left(\tan k\_m \cdot \left(\sin k\_m \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq 10^{+270}:\\
\;\;\;\;\frac{\frac{\ell \cdot \left(\frac{2}{\sin k\_m} \cdot \frac{\ell}{{t}^{3}}\right)}{\tan k\_m}}{2 + t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\end{array}
\end{array}
if (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) < 1e270Initial program 80.4%
Simplified82.5%
associate-/r/87.0%
div-inv87.0%
clear-num87.0%
Applied egg-rr87.0%
if 1e270 < (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) Initial program 31.8%
Simplified37.9%
add-cube-cbrt37.9%
pow337.9%
cbrt-div37.9%
rem-cbrt-cube56.1%
Applied egg-rr56.1%
*-un-lft-identity56.1%
associate-/r/54.2%
cube-div37.9%
pow337.9%
add-cube-cbrt37.9%
Applied egg-rr37.9%
*-lft-identity37.9%
*-commutative37.9%
associate-/l/37.9%
Simplified37.9%
*-un-lft-identity37.9%
associate-/l/37.9%
associate-*r/37.9%
associate-*l/37.9%
Applied egg-rr37.9%
*-lft-identity37.9%
associate-/l*37.9%
*-commutative37.9%
times-frac37.9%
associate-/r/37.9%
*-commutative37.9%
Simplified37.9%
Taylor expanded in k around inf 74.7%
associate-*r/74.7%
*-commutative74.7%
times-frac75.6%
Simplified75.6%
Final simplification82.3%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= t 9.6e-85)
(* (/ l (tan k_m)) (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(/
(/
(pow (/ (cbrt (/ 2.0 (sin k_m))) (/ t (pow (cbrt l) 2.0))) 3.0)
(tan k_m))
(+ 2.0 (pow (/ k_m t) 2.0)))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (t <= 9.6e-85) {
tmp = (l / tan(k_m)) * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else {
tmp = (pow((cbrt((2.0 / sin(k_m))) / (t / pow(cbrt(l), 2.0))), 3.0) / tan(k_m)) / (2.0 + pow((k_m / t), 2.0));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (t <= 9.6e-85) {
tmp = (l / Math.tan(k_m)) * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else {
tmp = (Math.pow((Math.cbrt((2.0 / Math.sin(k_m))) / (t / Math.pow(Math.cbrt(l), 2.0))), 3.0) / Math.tan(k_m)) / (2.0 + Math.pow((k_m / t), 2.0));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (t <= 9.6e-85) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); else tmp = Float64(Float64((Float64(cbrt(Float64(2.0 / sin(k_m))) / Float64(t / (cbrt(l) ^ 2.0))) ^ 3.0) / tan(k_m)) / Float64(2.0 + (Float64(k_m / t) ^ 2.0))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[t, 9.6e-85], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[N[(N[Power[N[(2.0 / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq 9.6 \cdot 10^{-85}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{{\left(\frac{\sqrt[3]{\frac{2}{\sin k\_m}}}{\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}}\right)}^{3}}{\tan k\_m}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}}\\
\end{array}
\end{array}
if t < 9.6000000000000002e-85Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 9.6000000000000002e-85 < t Initial program 64.4%
Simplified68.4%
add-cube-cbrt68.3%
pow268.3%
cbrt-div68.2%
associate-/r*65.0%
cbrt-div65.1%
rem-cbrt-cube65.1%
cbrt-prod68.2%
pow268.2%
cbrt-div68.2%
associate-/r*65.0%
cbrt-div65.0%
rem-cbrt-cube73.9%
cbrt-prod90.2%
pow290.2%
Applied egg-rr90.2%
unpow290.2%
unpow390.2%
Simplified90.2%
Final simplification80.5%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (/ (pow t 1.5) l)))
(if (<= t 1.6e-84)
(* (/ l (tan k_m)) (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(if (<= t 5.8e+203)
(/
(/ (* (/ 2.0 t_1) (/ (/ 1.0 (sin k_m)) t_1)) (tan k_m))
(+ 2.0 (pow (/ k_m t) 2.0)))
(/ 1.0 (pow (* (pow (cbrt k_m) 2.0) (* t (pow (cbrt l) -2.0))) 3.0))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = pow(t, 1.5) / l;
double tmp;
if (t <= 1.6e-84) {
tmp = (l / tan(k_m)) * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else if (t <= 5.8e+203) {
tmp = (((2.0 / t_1) * ((1.0 / sin(k_m)) / t_1)) / tan(k_m)) / (2.0 + pow((k_m / t), 2.0));
} else {
tmp = 1.0 / pow((pow(cbrt(k_m), 2.0) * (t * pow(cbrt(l), -2.0))), 3.0);
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = Math.pow(t, 1.5) / l;
double tmp;
if (t <= 1.6e-84) {
tmp = (l / Math.tan(k_m)) * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else if (t <= 5.8e+203) {
tmp = (((2.0 / t_1) * ((1.0 / Math.sin(k_m)) / t_1)) / Math.tan(k_m)) / (2.0 + Math.pow((k_m / t), 2.0));
} else {
tmp = 1.0 / Math.pow((Math.pow(Math.cbrt(k_m), 2.0) * (t * Math.pow(Math.cbrt(l), -2.0))), 3.0);
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64((t ^ 1.5) / l) tmp = 0.0 if (t <= 1.6e-84) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); elseif (t <= 5.8e+203) tmp = Float64(Float64(Float64(Float64(2.0 / t_1) * Float64(Float64(1.0 / sin(k_m)) / t_1)) / tan(k_m)) / Float64(2.0 + (Float64(k_m / t) ^ 2.0))); else tmp = Float64(1.0 / (Float64((cbrt(k_m) ^ 2.0) * Float64(t * (cbrt(l) ^ -2.0))) ^ 3.0)); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(N[Power[t, 1.5], $MachinePrecision] / l), $MachinePrecision]}, If[LessEqual[t, 1.6e-84], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.8e+203], N[(N[(N[(N[(2.0 / t$95$1), $MachinePrecision] * N[(N[(1.0 / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision] / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[Power[N[(N[Power[N[Power[k$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision] * N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{{t}^{1.5}}{\ell}\\
\mathbf{if}\;t \leq 1.6 \cdot 10^{-84}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{elif}\;t \leq 5.8 \cdot 10^{+203}:\\
\;\;\;\;\frac{\frac{\frac{2}{t\_1} \cdot \frac{\frac{1}{\sin k\_m}}{t\_1}}{\tan k\_m}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{{\left({\left(\sqrt[3]{k\_m}\right)}^{2} \cdot \left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)\right)}^{3}}\\
\end{array}
\end{array}
if t < 1.6e-84Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 1.6e-84 < t < 5.80000000000000021e203Initial program 60.3%
Simplified63.9%
div-inv63.9%
add-sqr-sqrt63.9%
times-frac63.9%
associate-/r*61.4%
sqrt-div61.3%
sqrt-pow161.3%
metadata-eval61.3%
sqrt-prod33.0%
add-sqr-sqrt45.3%
associate-/r*42.8%
sqrt-div42.8%
sqrt-pow149.8%
metadata-eval49.8%
sqrt-prod53.4%
add-sqr-sqrt91.0%
Applied egg-rr91.0%
if 5.80000000000000021e203 < t Initial program 76.0%
Simplified81.1%
Taylor expanded in k around 0 60.3%
*-commutative60.3%
Simplified60.3%
clear-num60.3%
inv-pow60.3%
Applied egg-rr60.3%
unpow-160.3%
*-commutative60.3%
Simplified60.3%
add-cube-cbrt60.3%
pow360.3%
Applied egg-rr99.6%
Final simplification81.4%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= t 1.45e-84)
(* (/ l (tan k_m)) (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(if (<= t 5.4e+140)
(/
(/ (* l (/ 2.0 (* (sin k_m) (* t (/ (pow t 2.0) l))))) (tan k_m))
(+ 2.0 (pow (/ k_m t) 2.0)))
(/ 1.0 (pow (* (pow (cbrt k_m) 2.0) (* t (pow (cbrt l) -2.0))) 3.0)))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.45e-84) {
tmp = (l / tan(k_m)) * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else if (t <= 5.4e+140) {
tmp = ((l * (2.0 / (sin(k_m) * (t * (pow(t, 2.0) / l))))) / tan(k_m)) / (2.0 + pow((k_m / t), 2.0));
} else {
tmp = 1.0 / pow((pow(cbrt(k_m), 2.0) * (t * pow(cbrt(l), -2.0))), 3.0);
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.45e-84) {
tmp = (l / Math.tan(k_m)) * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else if (t <= 5.4e+140) {
tmp = ((l * (2.0 / (Math.sin(k_m) * (t * (Math.pow(t, 2.0) / l))))) / Math.tan(k_m)) / (2.0 + Math.pow((k_m / t), 2.0));
} else {
tmp = 1.0 / Math.pow((Math.pow(Math.cbrt(k_m), 2.0) * (t * Math.pow(Math.cbrt(l), -2.0))), 3.0);
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (t <= 1.45e-84) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); elseif (t <= 5.4e+140) tmp = Float64(Float64(Float64(l * Float64(2.0 / Float64(sin(k_m) * Float64(t * Float64((t ^ 2.0) / l))))) / tan(k_m)) / Float64(2.0 + (Float64(k_m / t) ^ 2.0))); else tmp = Float64(1.0 / (Float64((cbrt(k_m) ^ 2.0) * Float64(t * (cbrt(l) ^ -2.0))) ^ 3.0)); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[t, 1.45e-84], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.4e+140], N[(N[(N[(l * N[(2.0 / N[(N[Sin[k$95$m], $MachinePrecision] * N[(t * N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[Power[N[(N[Power[N[Power[k$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision] * N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.45 \cdot 10^{-84}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{elif}\;t \leq 5.4 \cdot 10^{+140}:\\
\;\;\;\;\frac{\frac{\ell \cdot \frac{2}{\sin k\_m \cdot \left(t \cdot \frac{{t}^{2}}{\ell}\right)}}{\tan k\_m}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{{\left({\left(\sqrt[3]{k\_m}\right)}^{2} \cdot \left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)\right)}^{3}}\\
\end{array}
\end{array}
if t < 1.4500000000000001e-84Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 1.4500000000000001e-84 < t < 5.40000000000000036e140Initial program 63.6%
Simplified67.7%
add-cube-cbrt67.3%
pow367.3%
cbrt-div67.3%
rem-cbrt-cube77.5%
Applied egg-rr77.5%
*-un-lft-identity77.5%
associate-/r/89.4%
cube-div79.5%
pow379.4%
add-cube-cbrt79.8%
Applied egg-rr79.8%
*-lft-identity79.8%
*-commutative79.8%
associate-/l/79.8%
Simplified79.8%
cube-mult79.7%
*-un-lft-identity79.7%
times-frac89.8%
pow289.8%
Applied egg-rr89.8%
if 5.40000000000000036e140 < t Initial program 65.9%
Simplified69.6%
Taylor expanded in k around 0 51.0%
*-commutative51.0%
Simplified51.0%
clear-num51.0%
inv-pow51.0%
Applied egg-rr51.0%
unpow-151.0%
*-commutative51.0%
Simplified51.0%
add-cube-cbrt51.0%
pow351.0%
Applied egg-rr89.5%
Final simplification80.4%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= t 3.8e-85)
(* (/ l (tan k_m)) (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(if (<= t 9e+140)
(/
(/ (* l (/ 2.0 (* (sin k_m) (* t (/ (pow t 2.0) l))))) (tan k_m))
(+ 2.0 (pow (/ k_m t) 2.0)))
(pow (/ (cbrt (pow l 2.0)) (* t (pow (cbrt k_m) 2.0))) 3.0))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (t <= 3.8e-85) {
tmp = (l / tan(k_m)) * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else if (t <= 9e+140) {
tmp = ((l * (2.0 / (sin(k_m) * (t * (pow(t, 2.0) / l))))) / tan(k_m)) / (2.0 + pow((k_m / t), 2.0));
} else {
tmp = pow((cbrt(pow(l, 2.0)) / (t * pow(cbrt(k_m), 2.0))), 3.0);
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (t <= 3.8e-85) {
tmp = (l / Math.tan(k_m)) * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else if (t <= 9e+140) {
tmp = ((l * (2.0 / (Math.sin(k_m) * (t * (Math.pow(t, 2.0) / l))))) / Math.tan(k_m)) / (2.0 + Math.pow((k_m / t), 2.0));
} else {
tmp = Math.pow((Math.cbrt(Math.pow(l, 2.0)) / (t * Math.pow(Math.cbrt(k_m), 2.0))), 3.0);
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (t <= 3.8e-85) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); elseif (t <= 9e+140) tmp = Float64(Float64(Float64(l * Float64(2.0 / Float64(sin(k_m) * Float64(t * Float64((t ^ 2.0) / l))))) / tan(k_m)) / Float64(2.0 + (Float64(k_m / t) ^ 2.0))); else tmp = Float64(cbrt((l ^ 2.0)) / Float64(t * (cbrt(k_m) ^ 2.0))) ^ 3.0; end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[t, 3.8e-85], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9e+140], N[(N[(N[(l * N[(2.0 / N[(N[Sin[k$95$m], $MachinePrecision] * N[(t * N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[Power[N[Power[l, 2.0], $MachinePrecision], 1/3], $MachinePrecision] / N[(t * N[Power[N[Power[k$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.8 \cdot 10^{-85}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{elif}\;t \leq 9 \cdot 10^{+140}:\\
\;\;\;\;\frac{\frac{\ell \cdot \frac{2}{\sin k\_m \cdot \left(t \cdot \frac{{t}^{2}}{\ell}\right)}}{\tan k\_m}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{{\ell}^{2}}}{t \cdot {\left(\sqrt[3]{k\_m}\right)}^{2}}\right)}^{3}\\
\end{array}
\end{array}
if t < 3.7999999999999999e-85Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 3.7999999999999999e-85 < t < 9.0000000000000003e140Initial program 63.6%
Simplified67.7%
add-cube-cbrt67.3%
pow367.3%
cbrt-div67.3%
rem-cbrt-cube77.5%
Applied egg-rr77.5%
*-un-lft-identity77.5%
associate-/r/89.4%
cube-div79.5%
pow379.4%
add-cube-cbrt79.8%
Applied egg-rr79.8%
*-lft-identity79.8%
*-commutative79.8%
associate-/l/79.8%
Simplified79.8%
cube-mult79.7%
*-un-lft-identity79.7%
times-frac89.8%
pow289.8%
Applied egg-rr89.8%
if 9.0000000000000003e140 < t Initial program 65.9%
Simplified69.6%
Taylor expanded in k around 0 51.0%
*-commutative51.0%
Simplified51.0%
add-cube-cbrt51.0%
pow351.0%
cbrt-div51.0%
cbrt-prod51.0%
unpow351.0%
add-cbrt-cube61.5%
unpow261.5%
cbrt-prod85.8%
pow285.8%
Applied egg-rr85.8%
Final simplification80.0%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (/ l (tan k_m))) (t_2 (pow (/ k_m t) 2.0)))
(if (<= t 8.2e-85)
(* t_1 (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(if (<= t 2e+100)
(* t_1 (/ (* (/ 2.0 (sin k_m)) (/ l (pow t 3.0))) (+ 2.0 t_2)))
(if (<= t 8.2e+141)
(/
2.0
(*
(* (tan k_m) (* (sin k_m) (* (/ (pow t 2.0) l) (/ t l))))
(+ 1.0 (+ 1.0 t_2))))
(/ 1.0 (/ (pow (* t (pow (cbrt k_m) 2.0)) 3.0) (pow l 2.0))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = l / tan(k_m);
double t_2 = pow((k_m / t), 2.0);
double tmp;
if (t <= 8.2e-85) {
tmp = t_1 * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else if (t <= 2e+100) {
tmp = t_1 * (((2.0 / sin(k_m)) * (l / pow(t, 3.0))) / (2.0 + t_2));
} else if (t <= 8.2e+141) {
tmp = 2.0 / ((tan(k_m) * (sin(k_m) * ((pow(t, 2.0) / l) * (t / l)))) * (1.0 + (1.0 + t_2)));
} else {
tmp = 1.0 / (pow((t * pow(cbrt(k_m), 2.0)), 3.0) / pow(l, 2.0));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = l / Math.tan(k_m);
double t_2 = Math.pow((k_m / t), 2.0);
double tmp;
if (t <= 8.2e-85) {
tmp = t_1 * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else if (t <= 2e+100) {
tmp = t_1 * (((2.0 / Math.sin(k_m)) * (l / Math.pow(t, 3.0))) / (2.0 + t_2));
} else if (t <= 8.2e+141) {
tmp = 2.0 / ((Math.tan(k_m) * (Math.sin(k_m) * ((Math.pow(t, 2.0) / l) * (t / l)))) * (1.0 + (1.0 + t_2)));
} else {
tmp = 1.0 / (Math.pow((t * Math.pow(Math.cbrt(k_m), 2.0)), 3.0) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(l / tan(k_m)) t_2 = Float64(k_m / t) ^ 2.0 tmp = 0.0 if (t <= 8.2e-85) tmp = Float64(t_1 * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); elseif (t <= 2e+100) tmp = Float64(t_1 * Float64(Float64(Float64(2.0 / sin(k_m)) * Float64(l / (t ^ 3.0))) / Float64(2.0 + t_2))); elseif (t <= 8.2e+141) tmp = Float64(2.0 / Float64(Float64(tan(k_m) * Float64(sin(k_m) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))) * Float64(1.0 + Float64(1.0 + t_2)))); else tmp = Float64(1.0 / Float64((Float64(t * (cbrt(k_m) ^ 2.0)) ^ 3.0) / (l ^ 2.0))); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[t, 8.2e-85], N[(t$95$1 * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2e+100], N[(t$95$1 * N[(N[(N[(2.0 / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.2e+141], N[(2.0 / N[(N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(1.0 + t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Power[N[(t * N[Power[N[Power[k$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k\_m}\\
t_2 := {\left(\frac{k\_m}{t}\right)}^{2}\\
\mathbf{if}\;t \leq 8.2 \cdot 10^{-85}:\\
\;\;\;\;t\_1 \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{elif}\;t \leq 2 \cdot 10^{+100}:\\
\;\;\;\;t\_1 \cdot \frac{\frac{2}{\sin k\_m} \cdot \frac{\ell}{{t}^{3}}}{2 + t\_2}\\
\mathbf{elif}\;t \leq 8.2 \cdot 10^{+141}:\\
\;\;\;\;\frac{2}{\left(\tan k\_m \cdot \left(\sin k\_m \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)\right) \cdot \left(1 + \left(1 + t\_2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{{\left(t \cdot {\left(\sqrt[3]{k\_m}\right)}^{2}\right)}^{3}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if t < 8.19999999999999987e-85Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 8.19999999999999987e-85 < t < 2.00000000000000003e100Initial program 72.8%
Simplified77.6%
associate-/l/77.5%
associate-/r/92.5%
times-frac92.5%
div-inv92.5%
clear-num92.5%
Applied egg-rr92.5%
if 2.00000000000000003e100 < t < 8.20000000000000044e141Initial program 23.6%
unpow323.6%
times-frac78.4%
pow278.4%
Applied egg-rr78.4%
if 8.20000000000000044e141 < t Initial program 65.9%
Simplified69.6%
Taylor expanded in k around 0 51.0%
*-commutative51.0%
Simplified51.0%
clear-num51.0%
inv-pow51.0%
Applied egg-rr51.0%
unpow-151.0%
*-commutative51.0%
Simplified51.0%
add-cube-cbrt51.0%
pow351.0%
*-commutative51.0%
cbrt-prod51.0%
unpow351.0%
add-cbrt-cube54.9%
unpow254.9%
cbrt-prod76.2%
pow276.2%
Applied egg-rr76.2%
Final simplification78.9%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(if (<= t 1.65e-84)
(* (/ l (tan k_m)) (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(if (<= t 7e+139)
(/
(/ (* l (/ 2.0 (* (sin k_m) (* t (/ (pow t 2.0) l))))) (tan k_m))
(+ 2.0 (pow (/ k_m t) 2.0)))
(/ 1.0 (/ (pow (* t (pow (cbrt k_m) 2.0)) 3.0) (pow l 2.0))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.65e-84) {
tmp = (l / tan(k_m)) * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else if (t <= 7e+139) {
tmp = ((l * (2.0 / (sin(k_m) * (t * (pow(t, 2.0) / l))))) / tan(k_m)) / (2.0 + pow((k_m / t), 2.0));
} else {
tmp = 1.0 / (pow((t * pow(cbrt(k_m), 2.0)), 3.0) / pow(l, 2.0));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double tmp;
if (t <= 1.65e-84) {
tmp = (l / Math.tan(k_m)) * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else if (t <= 7e+139) {
tmp = ((l * (2.0 / (Math.sin(k_m) * (t * (Math.pow(t, 2.0) / l))))) / Math.tan(k_m)) / (2.0 + Math.pow((k_m / t), 2.0));
} else {
tmp = 1.0 / (Math.pow((t * Math.pow(Math.cbrt(k_m), 2.0)), 3.0) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (t <= 1.65e-84) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); elseif (t <= 7e+139) tmp = Float64(Float64(Float64(l * Float64(2.0 / Float64(sin(k_m) * Float64(t * Float64((t ^ 2.0) / l))))) / tan(k_m)) / Float64(2.0 + (Float64(k_m / t) ^ 2.0))); else tmp = Float64(1.0 / Float64((Float64(t * (cbrt(k_m) ^ 2.0)) ^ 3.0) / (l ^ 2.0))); end return tmp end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[t, 1.65e-84], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7e+139], N[(N[(N[(l * N[(2.0 / N[(N[Sin[k$95$m], $MachinePrecision] * N[(t * N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Power[N[(t * N[Power[N[Power[k$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.65 \cdot 10^{-84}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{elif}\;t \leq 7 \cdot 10^{+139}:\\
\;\;\;\;\frac{\frac{\ell \cdot \frac{2}{\sin k\_m \cdot \left(t \cdot \frac{{t}^{2}}{\ell}\right)}}{\tan k\_m}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{{\left(t \cdot {\left(\sqrt[3]{k\_m}\right)}^{2}\right)}^{3}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if t < 1.64999999999999992e-84Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 1.64999999999999992e-84 < t < 6.99999999999999957e139Initial program 63.6%
Simplified67.7%
add-cube-cbrt67.3%
pow367.3%
cbrt-div67.3%
rem-cbrt-cube77.5%
Applied egg-rr77.5%
*-un-lft-identity77.5%
associate-/r/89.4%
cube-div79.5%
pow379.4%
add-cube-cbrt79.8%
Applied egg-rr79.8%
*-lft-identity79.8%
*-commutative79.8%
associate-/l/79.8%
Simplified79.8%
cube-mult79.7%
*-un-lft-identity79.7%
times-frac89.8%
pow289.8%
Applied egg-rr89.8%
if 6.99999999999999957e139 < t Initial program 65.9%
Simplified69.6%
Taylor expanded in k around 0 51.0%
*-commutative51.0%
Simplified51.0%
clear-num51.0%
inv-pow51.0%
Applied egg-rr51.0%
unpow-151.0%
*-commutative51.0%
Simplified51.0%
add-cube-cbrt51.0%
pow351.0%
*-commutative51.0%
cbrt-prod51.0%
unpow351.0%
add-cbrt-cube54.9%
unpow254.9%
cbrt-prod76.2%
pow276.2%
Applied egg-rr76.2%
Final simplification78.9%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (/ l (tan k_m))))
(if (<= t 1.8e-33)
(* t_1 (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(if (<= t 5.6e+102)
(*
t_1
(/
(* l (/ 2.0 (* (sin k_m) (pow t 3.0))))
(+ 2.0 (pow (/ k_m t) 2.0))))
(/ 1.0 (/ (pow (* t (pow (cbrt k_m) 2.0)) 3.0) (pow l 2.0)))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = l / tan(k_m);
double tmp;
if (t <= 1.8e-33) {
tmp = t_1 * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else if (t <= 5.6e+102) {
tmp = t_1 * ((l * (2.0 / (sin(k_m) * pow(t, 3.0)))) / (2.0 + pow((k_m / t), 2.0)));
} else {
tmp = 1.0 / (pow((t * pow(cbrt(k_m), 2.0)), 3.0) / pow(l, 2.0));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = l / Math.tan(k_m);
double tmp;
if (t <= 1.8e-33) {
tmp = t_1 * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else if (t <= 5.6e+102) {
tmp = t_1 * ((l * (2.0 / (Math.sin(k_m) * Math.pow(t, 3.0)))) / (2.0 + Math.pow((k_m / t), 2.0)));
} else {
tmp = 1.0 / (Math.pow((t * Math.pow(Math.cbrt(k_m), 2.0)), 3.0) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(l / tan(k_m)) tmp = 0.0 if (t <= 1.8e-33) tmp = Float64(t_1 * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); elseif (t <= 5.6e+102) tmp = Float64(t_1 * Float64(Float64(l * Float64(2.0 / Float64(sin(k_m) * (t ^ 3.0)))) / Float64(2.0 + (Float64(k_m / t) ^ 2.0)))); else tmp = Float64(1.0 / Float64((Float64(t * (cbrt(k_m) ^ 2.0)) ^ 3.0) / (l ^ 2.0))); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 1.8e-33], N[(t$95$1 * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.6e+102], N[(t$95$1 * N[(N[(l * N[(2.0 / N[(N[Sin[k$95$m], $MachinePrecision] * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Power[N[(t * N[Power[N[Power[k$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k\_m}\\
\mathbf{if}\;t \leq 1.8 \cdot 10^{-33}:\\
\;\;\;\;t\_1 \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{elif}\;t \leq 5.6 \cdot 10^{+102}:\\
\;\;\;\;t\_1 \cdot \frac{\ell \cdot \frac{2}{\sin k\_m \cdot {t}^{3}}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{{\left(t \cdot {\left(\sqrt[3]{k\_m}\right)}^{2}\right)}^{3}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if t < 1.80000000000000017e-33Initial program 59.3%
Simplified63.0%
add-cube-cbrt62.9%
pow362.9%
cbrt-div62.9%
rem-cbrt-cube70.6%
Applied egg-rr70.6%
*-un-lft-identity70.6%
associate-/r/71.6%
cube-div64.9%
pow364.9%
add-cube-cbrt65.0%
Applied egg-rr65.0%
*-lft-identity65.0%
*-commutative65.0%
associate-/l/65.0%
Simplified65.0%
*-un-lft-identity65.0%
associate-/l/65.0%
associate-*r/65.0%
associate-*l/62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
associate-/l*62.5%
*-commutative62.5%
times-frac63.0%
associate-/r/62.6%
*-commutative62.6%
Simplified62.6%
Taylor expanded in k around inf 75.5%
associate-*r/75.5%
*-commutative75.5%
times-frac76.1%
Simplified76.1%
if 1.80000000000000017e-33 < t < 5.60000000000000037e102Initial program 70.0%
Simplified74.9%
add-cube-cbrt74.5%
pow374.5%
cbrt-div74.4%
rem-cbrt-cube74.5%
Applied egg-rr74.5%
*-un-lft-identity74.5%
associate-/r/85.2%
cube-div85.3%
pow385.2%
add-cube-cbrt85.8%
Applied egg-rr85.8%
*-lft-identity85.8%
*-commutative85.8%
associate-/l/85.8%
Simplified85.8%
*-un-lft-identity85.8%
associate-/l/85.7%
associate-*r/85.7%
associate-*l/82.2%
Applied egg-rr82.2%
*-lft-identity82.2%
associate-/l*82.2%
*-commutative82.2%
times-frac85.8%
associate-/r/85.6%
*-commutative85.6%
Simplified85.6%
if 5.60000000000000037e102 < t Initial program 57.0%
Simplified60.2%
Taylor expanded in k around 0 45.2%
*-commutative45.2%
Simplified45.2%
clear-num45.2%
inv-pow45.2%
Applied egg-rr45.2%
unpow-145.2%
*-commutative45.2%
Simplified45.2%
add-cube-cbrt45.2%
pow345.2%
*-commutative45.2%
cbrt-prod45.2%
unpow345.2%
add-cbrt-cube48.8%
unpow248.8%
cbrt-prod70.4%
pow270.4%
Applied egg-rr70.4%
Final simplification76.3%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (/ l (tan k_m))))
(if (<= t 5.2e-85)
(* t_1 (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m)))))
(if (<= t 1.75e+102)
(*
t_1
(/
(* (/ 2.0 (sin k_m)) (/ l (pow t 3.0)))
(+ 2.0 (pow (/ k_m t) 2.0))))
(/ 1.0 (/ (pow (* t (pow (cbrt k_m) 2.0)) 3.0) (pow l 2.0)))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = l / tan(k_m);
double tmp;
if (t <= 5.2e-85) {
tmp = t_1 * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
} else if (t <= 1.75e+102) {
tmp = t_1 * (((2.0 / sin(k_m)) * (l / pow(t, 3.0))) / (2.0 + pow((k_m / t), 2.0)));
} else {
tmp = 1.0 / (pow((t * pow(cbrt(k_m), 2.0)), 3.0) / pow(l, 2.0));
}
return tmp;
}
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = l / Math.tan(k_m);
double tmp;
if (t <= 5.2e-85) {
tmp = t_1 * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
} else if (t <= 1.75e+102) {
tmp = t_1 * (((2.0 / Math.sin(k_m)) * (l / Math.pow(t, 3.0))) / (2.0 + Math.pow((k_m / t), 2.0)));
} else {
tmp = 1.0 / (Math.pow((t * Math.pow(Math.cbrt(k_m), 2.0)), 3.0) / Math.pow(l, 2.0));
}
return tmp;
}
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(l / tan(k_m)) tmp = 0.0 if (t <= 5.2e-85) tmp = Float64(t_1 * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); elseif (t <= 1.75e+102) tmp = Float64(t_1 * Float64(Float64(Float64(2.0 / sin(k_m)) * Float64(l / (t ^ 3.0))) / Float64(2.0 + (Float64(k_m / t) ^ 2.0)))); else tmp = Float64(1.0 / Float64((Float64(t * (cbrt(k_m) ^ 2.0)) ^ 3.0) / (l ^ 2.0))); end return tmp end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 5.2e-85], N[(t$95$1 * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.75e+102], N[(t$95$1 * N[(N[(N[(2.0 / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[Power[N[(k$95$m / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Power[N[(t * N[Power[N[Power[k$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k\_m}\\
\mathbf{if}\;t \leq 5.2 \cdot 10^{-85}:\\
\;\;\;\;t\_1 \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{+102}:\\
\;\;\;\;t\_1 \cdot \frac{\frac{2}{\sin k\_m} \cdot \frac{\ell}{{t}^{3}}}{2 + {\left(\frac{k\_m}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{{\left(t \cdot {\left(\sqrt[3]{k\_m}\right)}^{2}\right)}^{3}}{{\ell}^{2}}}\\
\end{array}
\end{array}
if t < 5.20000000000000023e-85Initial program 58.2%
Simplified61.9%
add-cube-cbrt61.9%
pow361.9%
cbrt-div61.9%
rem-cbrt-cube70.1%
Applied egg-rr70.1%
*-un-lft-identity70.1%
associate-/r/69.6%
cube-div62.4%
pow362.4%
add-cube-cbrt62.5%
Applied egg-rr62.5%
*-lft-identity62.5%
*-commutative62.5%
associate-/l/62.5%
Simplified62.5%
*-un-lft-identity62.5%
associate-/l/62.5%
associate-*r/62.5%
associate-*l/61.5%
Applied egg-rr61.5%
*-lft-identity61.5%
associate-/l*61.5%
*-commutative61.5%
times-frac62.1%
associate-/r/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in k around inf 75.9%
associate-*r/75.9%
*-commutative75.9%
times-frac76.5%
Simplified76.5%
if 5.20000000000000023e-85 < t < 1.75000000000000005e102Initial program 72.8%
Simplified77.6%
associate-/l/77.5%
associate-/r/92.5%
times-frac92.5%
div-inv92.5%
clear-num92.5%
Applied egg-rr92.5%
if 1.75000000000000005e102 < t Initial program 55.6%
Simplified58.7%
Taylor expanded in k around 0 44.0%
*-commutative44.0%
Simplified44.0%
clear-num44.0%
inv-pow44.0%
Applied egg-rr44.0%
unpow-144.0%
*-commutative44.0%
Simplified44.0%
add-cube-cbrt44.0%
pow344.0%
*-commutative44.0%
cbrt-prod44.0%
unpow344.0%
add-cbrt-cube47.5%
unpow247.5%
cbrt-prod68.6%
pow268.6%
Applied egg-rr68.6%
Final simplification77.8%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (/ l (tan k_m))))
(if (<= k_m 2.65e-49)
(* t_1 (/ (/ l k_m) (pow t 3.0)))
(* t_1 (* 2.0 (/ l (* (pow k_m 2.0) (* t (sin k_m)))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = l / tan(k_m);
double tmp;
if (k_m <= 2.65e-49) {
tmp = t_1 * ((l / k_m) / pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (pow(k_m, 2.0) * (t * sin(k_m)))));
}
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) :: t_1
real(8) :: tmp
t_1 = l / tan(k_m)
if (k_m <= 2.65d-49) then
tmp = t_1 * ((l / k_m) / (t ** 3.0d0))
else
tmp = t_1 * (2.0d0 * (l / ((k_m ** 2.0d0) * (t * sin(k_m)))))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = l / Math.tan(k_m);
double tmp;
if (k_m <= 2.65e-49) {
tmp = t_1 * ((l / k_m) / Math.pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (Math.pow(k_m, 2.0) * (t * Math.sin(k_m)))));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): t_1 = l / math.tan(k_m) tmp = 0 if k_m <= 2.65e-49: tmp = t_1 * ((l / k_m) / math.pow(t, 3.0)) else: tmp = t_1 * (2.0 * (l / (math.pow(k_m, 2.0) * (t * math.sin(k_m))))) return tmp
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(l / tan(k_m)) tmp = 0.0 if (k_m <= 2.65e-49) tmp = Float64(t_1 * Float64(Float64(l / k_m) / (t ^ 3.0))); else tmp = Float64(t_1 * Float64(2.0 * Float64(l / Float64((k_m ^ 2.0) * Float64(t * sin(k_m)))))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) t_1 = l / tan(k_m); tmp = 0.0; if (k_m <= 2.65e-49) tmp = t_1 * ((l / k_m) / (t ^ 3.0)); else tmp = t_1 * (2.0 * (l / ((k_m ^ 2.0) * (t * sin(k_m))))); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k$95$m, 2.65e-49], N[(t$95$1 * N[(N[(l / k$95$m), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(2.0 * N[(l / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k\_m}\\
\mathbf{if}\;k\_m \leq 2.65 \cdot 10^{-49}:\\
\;\;\;\;t\_1 \cdot \frac{\frac{\ell}{k\_m}}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(2 \cdot \frac{\ell}{{k\_m}^{2} \cdot \left(t \cdot \sin k\_m\right)}\right)\\
\end{array}
\end{array}
if k < 2.6500000000000001e-49Initial program 64.3%
Simplified68.5%
add-cube-cbrt68.4%
pow368.4%
cbrt-div68.4%
rem-cbrt-cube76.2%
Applied egg-rr76.2%
*-un-lft-identity76.2%
associate-/r/78.5%
cube-div71.7%
pow371.7%
add-cube-cbrt71.9%
Applied egg-rr71.9%
*-lft-identity71.9%
*-commutative71.9%
associate-/l/71.9%
Simplified71.9%
*-un-lft-identity71.9%
associate-/l/71.9%
associate-*r/71.8%
associate-*l/69.0%
Applied egg-rr69.0%
*-lft-identity69.0%
associate-/l*69.1%
*-commutative69.1%
times-frac69.9%
associate-/r/69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in k around 0 67.5%
associate-/r*69.8%
Simplified69.8%
if 2.6500000000000001e-49 < k Initial program 43.9%
Simplified46.0%
add-cube-cbrt45.9%
pow345.9%
cbrt-div45.9%
rem-cbrt-cube55.1%
Applied egg-rr55.1%
*-un-lft-identity55.1%
associate-/r/55.1%
cube-div46.0%
pow346.0%
add-cube-cbrt46.0%
Applied egg-rr46.0%
*-lft-identity46.0%
*-commutative46.0%
associate-/l/46.0%
Simplified46.0%
*-un-lft-identity46.0%
associate-/l/46.0%
associate-*r/46.0%
associate-*l/46.0%
Applied egg-rr46.0%
*-lft-identity46.0%
associate-/l*46.0%
*-commutative46.0%
times-frac46.2%
associate-/r/46.1%
*-commutative46.1%
Simplified46.1%
Taylor expanded in k around inf 67.2%
Final simplification69.3%
k_m = (fabs.f64 k)
(FPCore (t l k_m)
:precision binary64
(let* ((t_1 (/ l (tan k_m))))
(if (<= k_m 1.2e-50)
(* t_1 (/ (/ l k_m) (pow t 3.0)))
(* t_1 (* (/ l (pow k_m 2.0)) (/ 2.0 (* t (sin k_m))))))))k_m = fabs(k);
double code(double t, double l, double k_m) {
double t_1 = l / tan(k_m);
double tmp;
if (k_m <= 1.2e-50) {
tmp = t_1 * ((l / k_m) / pow(t, 3.0));
} else {
tmp = t_1 * ((l / pow(k_m, 2.0)) * (2.0 / (t * sin(k_m))));
}
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) :: t_1
real(8) :: tmp
t_1 = l / tan(k_m)
if (k_m <= 1.2d-50) then
tmp = t_1 * ((l / k_m) / (t ** 3.0d0))
else
tmp = t_1 * ((l / (k_m ** 2.0d0)) * (2.0d0 / (t * sin(k_m))))
end if
code = tmp
end function
k_m = Math.abs(k);
public static double code(double t, double l, double k_m) {
double t_1 = l / Math.tan(k_m);
double tmp;
if (k_m <= 1.2e-50) {
tmp = t_1 * ((l / k_m) / Math.pow(t, 3.0));
} else {
tmp = t_1 * ((l / Math.pow(k_m, 2.0)) * (2.0 / (t * Math.sin(k_m))));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): t_1 = l / math.tan(k_m) tmp = 0 if k_m <= 1.2e-50: tmp = t_1 * ((l / k_m) / math.pow(t, 3.0)) else: tmp = t_1 * ((l / math.pow(k_m, 2.0)) * (2.0 / (t * math.sin(k_m)))) return tmp
k_m = abs(k) function code(t, l, k_m) t_1 = Float64(l / tan(k_m)) tmp = 0.0 if (k_m <= 1.2e-50) tmp = Float64(t_1 * Float64(Float64(l / k_m) / (t ^ 3.0))); else tmp = Float64(t_1 * Float64(Float64(l / (k_m ^ 2.0)) * Float64(2.0 / Float64(t * sin(k_m))))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) t_1 = l / tan(k_m); tmp = 0.0; if (k_m <= 1.2e-50) tmp = t_1 * ((l / k_m) / (t ^ 3.0)); else tmp = t_1 * ((l / (k_m ^ 2.0)) * (2.0 / (t * sin(k_m)))); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision]
code[t_, l_, k$95$m_] := Block[{t$95$1 = N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k$95$m, 1.2e-50], N[(t$95$1 * N[(N[(l / k$95$m), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(N[(l / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / N[(t * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k\_m}\\
\mathbf{if}\;k\_m \leq 1.2 \cdot 10^{-50}:\\
\;\;\;\;t\_1 \cdot \frac{\frac{\ell}{k\_m}}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(\frac{\ell}{{k\_m}^{2}} \cdot \frac{2}{t \cdot \sin k\_m}\right)\\
\end{array}
\end{array}
if k < 1.20000000000000001e-50Initial program 64.3%
Simplified68.5%
add-cube-cbrt68.4%
pow368.4%
cbrt-div68.4%
rem-cbrt-cube76.2%
Applied egg-rr76.2%
*-un-lft-identity76.2%
associate-/r/78.5%
cube-div71.7%
pow371.7%
add-cube-cbrt71.9%
Applied egg-rr71.9%
*-lft-identity71.9%
*-commutative71.9%
associate-/l/71.9%
Simplified71.9%
*-un-lft-identity71.9%
associate-/l/71.9%
associate-*r/71.8%
associate-*l/69.0%
Applied egg-rr69.0%
*-lft-identity69.0%
associate-/l*69.1%
*-commutative69.1%
times-frac69.9%
associate-/r/69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in k around 0 67.5%
associate-/r*69.8%
Simplified69.8%
if 1.20000000000000001e-50 < k Initial program 43.9%
Simplified46.0%
add-cube-cbrt45.9%
pow345.9%
cbrt-div45.9%
rem-cbrt-cube55.1%
Applied egg-rr55.1%
*-un-lft-identity55.1%
associate-/r/55.1%
cube-div46.0%
pow346.0%
add-cube-cbrt46.0%
Applied egg-rr46.0%
*-lft-identity46.0%
*-commutative46.0%
associate-/l/46.0%
Simplified46.0%
*-un-lft-identity46.0%
associate-/l/46.0%
associate-*r/46.0%
associate-*l/46.0%
Applied egg-rr46.0%
*-lft-identity46.0%
associate-/l*46.0%
*-commutative46.0%
times-frac46.2%
associate-/r/46.1%
*-commutative46.1%
Simplified46.1%
Taylor expanded in k around inf 67.2%
associate-*r/67.2%
*-commutative67.2%
times-frac70.7%
Simplified70.7%
Final simplification70.0%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 2.65e-49) (* (/ l (tan k_m)) (/ (/ l k_m) (pow t 3.0))) (* 2.0 (* (pow l 2.0) (/ (cos k_m) (* t (pow k_m 4.0)))))))
k_m = fabs(k);
double code(double t, double l, double k_m) {
double tmp;
if (k_m <= 2.65e-49) {
tmp = (l / tan(k_m)) * ((l / k_m) / pow(t, 3.0));
} else {
tmp = 2.0 * (pow(l, 2.0) * (cos(k_m) / (t * pow(k_m, 4.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.65d-49) then
tmp = (l / tan(k_m)) * ((l / k_m) / (t ** 3.0d0))
else
tmp = 2.0d0 * ((l ** 2.0d0) * (cos(k_m) / (t * (k_m ** 4.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.65e-49) {
tmp = (l / Math.tan(k_m)) * ((l / k_m) / Math.pow(t, 3.0));
} else {
tmp = 2.0 * (Math.pow(l, 2.0) * (Math.cos(k_m) / (t * Math.pow(k_m, 4.0))));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if k_m <= 2.65e-49: tmp = (l / math.tan(k_m)) * ((l / k_m) / math.pow(t, 3.0)) else: tmp = 2.0 * (math.pow(l, 2.0) * (math.cos(k_m) / (t * math.pow(k_m, 4.0)))) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 2.65e-49) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / k_m) / (t ^ 3.0))); else tmp = Float64(2.0 * Float64((l ^ 2.0) * Float64(cos(k_m) / Float64(t * (k_m ^ 4.0))))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (k_m <= 2.65e-49) tmp = (l / tan(k_m)) * ((l / k_m) / (t ^ 3.0)); else tmp = 2.0 * ((l ^ 2.0) * (cos(k_m) / (t * (k_m ^ 4.0)))); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 2.65e-49], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / k$95$m), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Power[l, 2.0], $MachinePrecision] * N[(N[Cos[k$95$m], $MachinePrecision] / N[(t * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k_m = \left|k\right|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 2.65 \cdot 10^{-49}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \frac{\frac{\ell}{k\_m}}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left({\ell}^{2} \cdot \frac{\cos k\_m}{t \cdot {k\_m}^{4}}\right)\\
\end{array}
\end{array}
if k < 2.6500000000000001e-49Initial program 64.3%
Simplified68.5%
add-cube-cbrt68.4%
pow368.4%
cbrt-div68.4%
rem-cbrt-cube76.2%
Applied egg-rr76.2%
*-un-lft-identity76.2%
associate-/r/78.5%
cube-div71.7%
pow371.7%
add-cube-cbrt71.9%
Applied egg-rr71.9%
*-lft-identity71.9%
*-commutative71.9%
associate-/l/71.9%
Simplified71.9%
*-un-lft-identity71.9%
associate-/l/71.9%
associate-*r/71.8%
associate-*l/69.0%
Applied egg-rr69.0%
*-lft-identity69.0%
associate-/l*69.1%
*-commutative69.1%
times-frac69.9%
associate-/r/69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in k around 0 67.5%
associate-/r*69.8%
Simplified69.8%
if 2.6500000000000001e-49 < k Initial program 43.9%
Simplified46.0%
associate-/l/45.9%
add-cube-cbrt46.0%
times-frac46.0%
Applied egg-rr67.9%
pow1/332.7%
add-sqr-sqrt32.7%
unpow-prod-down32.7%
Applied egg-rr32.7%
unpow1/333.0%
unpow1/333.8%
Simplified33.8%
Taylor expanded in k around inf 59.9%
associate-/l*59.9%
*-commutative59.9%
Simplified59.9%
Taylor expanded in k around 0 47.0%
Final simplification65.1%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 3e-49) (* (/ l (tan k_m)) (/ l (* k_m (pow t 3.0)))) (* 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) {
double tmp;
if (k_m <= 3e-49) {
tmp = (l / tan(k_m)) * (l / (k_m * pow(t, 3.0)));
} else {
tmp = 2.0 * (pow(l, 2.0) / (t * pow(k_m, 4.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 <= 3d-49) then
tmp = (l / tan(k_m)) * (l / (k_m * (t ** 3.0d0)))
else
tmp = 2.0d0 * ((l ** 2.0d0) / (t * (k_m ** 4.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 <= 3e-49) {
tmp = (l / Math.tan(k_m)) * (l / (k_m * Math.pow(t, 3.0)));
} else {
tmp = 2.0 * (Math.pow(l, 2.0) / (t * Math.pow(k_m, 4.0)));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if k_m <= 3e-49: tmp = (l / math.tan(k_m)) * (l / (k_m * math.pow(t, 3.0))) else: tmp = 2.0 * (math.pow(l, 2.0) / (t * math.pow(k_m, 4.0))) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 3e-49) tmp = Float64(Float64(l / tan(k_m)) * Float64(l / Float64(k_m * (t ^ 3.0)))); else tmp = Float64(2.0 * Float64((l ^ 2.0) / Float64(t * (k_m ^ 4.0)))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (k_m <= 3e-49) tmp = (l / tan(k_m)) * (l / (k_m * (t ^ 3.0))); else tmp = 2.0 * ((l ^ 2.0) / (t * (k_m ^ 4.0))); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 3e-49], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(l / N[(k$95$m * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 3 \cdot 10^{-49}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \frac{\ell}{k\_m \cdot {t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2}}{t \cdot {k\_m}^{4}}\\
\end{array}
\end{array}
if k < 3e-49Initial program 64.3%
Simplified68.5%
add-cube-cbrt68.4%
pow368.4%
cbrt-div68.4%
rem-cbrt-cube76.2%
Applied egg-rr76.2%
*-un-lft-identity76.2%
associate-/r/78.5%
cube-div71.7%
pow371.7%
add-cube-cbrt71.9%
Applied egg-rr71.9%
*-lft-identity71.9%
*-commutative71.9%
associate-/l/71.9%
Simplified71.9%
*-un-lft-identity71.9%
associate-/l/71.9%
associate-*r/71.8%
associate-*l/69.0%
Applied egg-rr69.0%
*-lft-identity69.0%
associate-/l*69.1%
*-commutative69.1%
times-frac69.9%
associate-/r/69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in k around 0 67.5%
if 3e-49 < k Initial program 43.9%
Simplified46.0%
associate-/l/45.9%
add-cube-cbrt46.0%
times-frac46.0%
Applied egg-rr67.9%
pow1/332.7%
add-sqr-sqrt32.7%
unpow-prod-down32.7%
Applied egg-rr32.7%
unpow1/333.0%
unpow1/333.8%
Simplified33.8%
Taylor expanded in k around inf 59.9%
associate-/l*59.9%
*-commutative59.9%
Simplified59.9%
Taylor expanded in k around 0 47.0%
Final simplification63.2%
k_m = (fabs.f64 k) (FPCore (t l k_m) :precision binary64 (if (<= k_m 2.65e-49) (* (/ l (tan k_m)) (/ (/ l k_m) (pow t 3.0))) (* 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) {
double tmp;
if (k_m <= 2.65e-49) {
tmp = (l / tan(k_m)) * ((l / k_m) / pow(t, 3.0));
} else {
tmp = 2.0 * (pow(l, 2.0) / (t * pow(k_m, 4.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.65d-49) then
tmp = (l / tan(k_m)) * ((l / k_m) / (t ** 3.0d0))
else
tmp = 2.0d0 * ((l ** 2.0d0) / (t * (k_m ** 4.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.65e-49) {
tmp = (l / Math.tan(k_m)) * ((l / k_m) / Math.pow(t, 3.0));
} else {
tmp = 2.0 * (Math.pow(l, 2.0) / (t * Math.pow(k_m, 4.0)));
}
return tmp;
}
k_m = math.fabs(k) def code(t, l, k_m): tmp = 0 if k_m <= 2.65e-49: tmp = (l / math.tan(k_m)) * ((l / k_m) / math.pow(t, 3.0)) else: tmp = 2.0 * (math.pow(l, 2.0) / (t * math.pow(k_m, 4.0))) return tmp
k_m = abs(k) function code(t, l, k_m) tmp = 0.0 if (k_m <= 2.65e-49) tmp = Float64(Float64(l / tan(k_m)) * Float64(Float64(l / k_m) / (t ^ 3.0))); else tmp = Float64(2.0 * Float64((l ^ 2.0) / Float64(t * (k_m ^ 4.0)))); end return tmp end
k_m = abs(k); function tmp_2 = code(t, l, k_m) tmp = 0.0; if (k_m <= 2.65e-49) tmp = (l / tan(k_m)) * ((l / k_m) / (t ^ 3.0)); else tmp = 2.0 * ((l ^ 2.0) / (t * (k_m ^ 4.0))); end tmp_2 = tmp; end
k_m = N[Abs[k], $MachinePrecision] code[t_, l_, k$95$m_] := If[LessEqual[k$95$m, 2.65e-49], N[(N[(l / N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(l / k$95$m), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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|
\\
\begin{array}{l}
\mathbf{if}\;k\_m \leq 2.65 \cdot 10^{-49}:\\
\;\;\;\;\frac{\ell}{\tan k\_m} \cdot \frac{\frac{\ell}{k\_m}}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2}}{t \cdot {k\_m}^{4}}\\
\end{array}
\end{array}
if k < 2.6500000000000001e-49Initial program 64.3%
Simplified68.5%
add-cube-cbrt68.4%
pow368.4%
cbrt-div68.4%
rem-cbrt-cube76.2%
Applied egg-rr76.2%
*-un-lft-identity76.2%
associate-/r/78.5%
cube-div71.7%
pow371.7%
add-cube-cbrt71.9%
Applied egg-rr71.9%
*-lft-identity71.9%
*-commutative71.9%
associate-/l/71.9%
Simplified71.9%
*-un-lft-identity71.9%
associate-/l/71.9%
associate-*r/71.8%
associate-*l/69.0%
Applied egg-rr69.0%
*-lft-identity69.0%
associate-/l*69.1%
*-commutative69.1%
times-frac69.9%
associate-/r/69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in k around 0 67.5%
associate-/r*69.8%
Simplified69.8%
if 2.6500000000000001e-49 < k Initial program 43.9%
Simplified46.0%
associate-/l/45.9%
add-cube-cbrt46.0%
times-frac46.0%
Applied egg-rr67.9%
pow1/332.7%
add-sqr-sqrt32.7%
unpow-prod-down32.7%
Applied egg-rr32.7%
unpow1/333.0%
unpow1/333.8%
Simplified33.8%
Taylor expanded in k around inf 59.9%
associate-/l*59.9%
*-commutative59.9%
Simplified59.9%
Taylor expanded in k around 0 47.0%
Final simplification65.1%
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 60.1%
Simplified63.8%
associate-/l/63.8%
add-cube-cbrt63.8%
times-frac63.8%
Applied egg-rr83.8%
pow1/341.4%
add-sqr-sqrt41.4%
unpow-prod-down41.4%
Applied egg-rr41.4%
unpow1/341.6%
unpow1/342.4%
Simplified42.4%
Taylor expanded in k around inf 64.0%
associate-/l*63.6%
*-commutative63.6%
Simplified63.6%
Taylor expanded in k around 0 55.0%
Final simplification55.0%
herbie shell --seed 2024052
(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))))