
(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 19 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))
(t_2 (cbrt (* (sin k) (tan k))))
(t_3 (* t_1 t_2))
(t_4 (/ (sqrt 2.0) k)))
(if (<= (* l l) 1e-271)
(* (* (sqrt 2.0) (/ t k)) (* (pow (* t t_3) -2.0) (/ t_4 t_3)))
(if (<= (* l l) 1e+213)
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))
(*
(/ (* t t_4) (pow (* t_2 (/ t (pow (cbrt l) 2.0))) 2.0))
(/ (/ t_4 t_1) t_2))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), -2.0);
double t_2 = cbrt((sin(k) * tan(k)));
double t_3 = t_1 * t_2;
double t_4 = sqrt(2.0) / k;
double tmp;
if ((l * l) <= 1e-271) {
tmp = (sqrt(2.0) * (t / k)) * (pow((t * t_3), -2.0) * (t_4 / t_3));
} else if ((l * l) <= 1e+213) {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
} else {
tmp = ((t * t_4) / pow((t_2 * (t / pow(cbrt(l), 2.0))), 2.0)) * ((t_4 / t_1) / t_2);
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.cbrt(l), -2.0);
double t_2 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_3 = t_1 * t_2;
double t_4 = Math.sqrt(2.0) / k;
double tmp;
if ((l * l) <= 1e-271) {
tmp = (Math.sqrt(2.0) * (t / k)) * (Math.pow((t * t_3), -2.0) * (t_4 / t_3));
} else if ((l * l) <= 1e+213) {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
} else {
tmp = ((t * t_4) / Math.pow((t_2 * (t / Math.pow(Math.cbrt(l), 2.0))), 2.0)) * ((t_4 / t_1) / t_2);
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(l) ^ -2.0 t_2 = cbrt(Float64(sin(k) * tan(k))) t_3 = Float64(t_1 * t_2) t_4 = Float64(sqrt(2.0) / k) tmp = 0.0 if (Float64(l * l) <= 1e-271) tmp = Float64(Float64(sqrt(2.0) * Float64(t / k)) * Float64((Float64(t * t_3) ^ -2.0) * Float64(t_4 / t_3))); elseif (Float64(l * l) <= 1e+213) tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); else tmp = Float64(Float64(Float64(t * t_4) / (Float64(t_2 * Float64(t / (cbrt(l) ^ 2.0))) ^ 2.0)) * Float64(Float64(t_4 / t_1) / t_2)); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 * t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]}, If[LessEqual[N[(l * l), $MachinePrecision], 1e-271], N[(N[(N[Sqrt[2.0], $MachinePrecision] * N[(t / k), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t * t$95$3), $MachinePrecision], -2.0], $MachinePrecision] * N[(t$95$4 / t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 1e+213], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t * t$95$4), $MachinePrecision] / N[Power[N[(t$95$2 * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$4 / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t_2 := \sqrt[3]{\sin k \cdot \tan k}\\
t_3 := t\_1 \cdot t\_2\\
t_4 := \frac{\sqrt{2}}{k}\\
\mathbf{if}\;\ell \cdot \ell \leq 10^{-271}:\\
\;\;\;\;\left(\sqrt{2} \cdot \frac{t}{k}\right) \cdot \left({\left(t \cdot t\_3\right)}^{-2} \cdot \frac{t\_4}{t\_3}\right)\\
\mathbf{elif}\;\ell \cdot \ell \leq 10^{+213}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot t\_4}{{\left(t\_2 \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{2}} \cdot \frac{\frac{t\_4}{t\_1}}{t\_2}\\
\end{array}
\end{array}
if (*.f64 l l) < 9.99999999999999963e-272Initial program 27.4%
*-commutative27.4%
associate-/r*27.4%
Simplified39.9%
add-sqr-sqrt39.9%
add-cube-cbrt39.9%
times-frac39.9%
Applied egg-rr85.2%
associate-/r/85.2%
associate-/r*85.3%
associate-/r/85.2%
Simplified85.2%
associate-*r/85.2%
Applied egg-rr85.3%
associate-*r/85.3%
associate-*l*85.3%
associate-*l/85.2%
*-commutative85.2%
associate-*l*85.2%
Simplified87.7%
pow187.7%
associate-*r*87.7%
associate-*r/87.7%
associate-*r*85.3%
Applied egg-rr85.3%
unpow185.3%
associate-*l*85.3%
*-commutative85.3%
associate-/l*85.3%
associate-*l*87.7%
associate-/r*87.7%
Simplified87.7%
if 9.99999999999999963e-272 < (*.f64 l l) < 9.99999999999999984e212Initial program 41.4%
*-commutative41.4%
associate-/r*41.5%
Simplified49.0%
add-sqr-sqrt49.0%
add-cube-cbrt48.9%
times-frac48.9%
Applied egg-rr76.3%
associate-/r/76.3%
associate-/r*76.3%
associate-/r/76.4%
Simplified76.4%
Taylor expanded in k around inf 90.3%
times-frac91.9%
*-commutative91.9%
unpow291.9%
rem-square-sqrt92.2%
*-commutative92.2%
times-frac92.2%
Simplified92.2%
if 9.99999999999999984e212 < (*.f64 l l) Initial program 35.1%
*-commutative35.1%
associate-/r*35.1%
Simplified35.1%
add-sqr-sqrt35.1%
add-cube-cbrt35.1%
times-frac35.1%
Applied egg-rr86.2%
associate-/r/86.2%
associate-/r*86.2%
associate-/r/86.1%
Simplified86.1%
div-inv86.1%
associate-/l*86.2%
div-inv86.1%
pow-flip86.1%
metadata-eval86.1%
Applied egg-rr86.1%
associate-*r/86.2%
*-rgt-identity86.2%
*-commutative86.2%
associate-/r*86.2%
*-inverses86.2%
associate-*l/86.2%
*-lft-identity86.2%
Simplified86.2%
Final simplification88.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* (pow (cbrt l) -2.0) (cbrt (* (sin k) (tan k))))))
(if (or (<= (* l l) 1e-271) (not (<= (* l l) 1e+213)))
(*
(* (sqrt 2.0) (/ t k))
(* (pow (* t t_1) -2.0) (/ (/ (sqrt 2.0) k) t_1)))
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), -2.0) * cbrt((sin(k) * tan(k)));
double tmp;
if (((l * l) <= 1e-271) || !((l * l) <= 1e+213)) {
tmp = (sqrt(2.0) * (t / k)) * (pow((t * t_1), -2.0) * ((sqrt(2.0) / k) / t_1));
} else {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.cbrt(l), -2.0) * Math.cbrt((Math.sin(k) * Math.tan(k)));
double tmp;
if (((l * l) <= 1e-271) || !((l * l) <= 1e+213)) {
tmp = (Math.sqrt(2.0) * (t / k)) * (Math.pow((t * t_1), -2.0) * ((Math.sqrt(2.0) / k) / t_1));
} else {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
}
return tmp;
}
function code(t, l, k) t_1 = Float64((cbrt(l) ^ -2.0) * cbrt(Float64(sin(k) * tan(k)))) tmp = 0.0 if ((Float64(l * l) <= 1e-271) || !(Float64(l * l) <= 1e+213)) tmp = Float64(Float64(sqrt(2.0) * Float64(t / k)) * Float64((Float64(t * t_1) ^ -2.0) * Float64(Float64(sqrt(2.0) / k) / t_1))); else tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision] * N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[N[(l * l), $MachinePrecision], 1e-271], N[Not[LessEqual[N[(l * l), $MachinePrecision], 1e+213]], $MachinePrecision]], N[(N[(N[Sqrt[2.0], $MachinePrecision] * N[(t / k), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t * t$95$1), $MachinePrecision], -2.0], $MachinePrecision] * N[(N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{-2} \cdot \sqrt[3]{\sin k \cdot \tan k}\\
\mathbf{if}\;\ell \cdot \ell \leq 10^{-271} \lor \neg \left(\ell \cdot \ell \leq 10^{+213}\right):\\
\;\;\;\;\left(\sqrt{2} \cdot \frac{t}{k}\right) \cdot \left({\left(t \cdot t\_1\right)}^{-2} \cdot \frac{\frac{\sqrt{2}}{k}}{t\_1}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\end{array}
\end{array}
if (*.f64 l l) < 9.99999999999999963e-272 or 9.99999999999999984e212 < (*.f64 l l) Initial program 30.9%
*-commutative30.9%
associate-/r*30.9%
Simplified37.7%
add-sqr-sqrt37.7%
add-cube-cbrt37.7%
times-frac37.7%
Applied egg-rr85.7%
associate-/r/85.7%
associate-/r*85.7%
associate-/r/85.6%
Simplified85.6%
associate-*r/85.7%
Applied egg-rr85.6%
associate-*r/85.6%
associate-*l*85.1%
associate-*l/85.1%
*-commutative85.1%
associate-*l*85.1%
Simplified86.5%
pow186.5%
associate-*r*87.0%
associate-*r/87.0%
associate-*r*85.6%
Applied egg-rr85.6%
unpow185.6%
associate-*l*85.1%
*-commutative85.1%
associate-/l*85.1%
associate-*l*86.4%
associate-/r*86.5%
Simplified86.5%
if 9.99999999999999963e-272 < (*.f64 l l) < 9.99999999999999984e212Initial program 41.4%
*-commutative41.4%
associate-/r*41.5%
Simplified49.0%
add-sqr-sqrt49.0%
add-cube-cbrt48.9%
times-frac48.9%
Applied egg-rr76.3%
associate-/r/76.3%
associate-/r*76.3%
associate-/r/76.4%
Simplified76.4%
Taylor expanded in k around inf 90.3%
times-frac91.9%
*-commutative91.9%
unpow291.9%
rem-square-sqrt92.2%
*-commutative92.2%
times-frac92.2%
Simplified92.2%
Final simplification88.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (cbrt l) -2.0))
(t_2 (cbrt (* (sin k) (tan k))))
(t_3 (/ (sqrt 2.0) k)))
(if (or (<= (* l l) 1e-271) (not (<= (* l l) 1e+213)))
(* (* t t_3) (* (pow (* t (* t_1 t_2)) -2.0) (/ (/ t_3 t_1) t_2)))
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), -2.0);
double t_2 = cbrt((sin(k) * tan(k)));
double t_3 = sqrt(2.0) / k;
double tmp;
if (((l * l) <= 1e-271) || !((l * l) <= 1e+213)) {
tmp = (t * t_3) * (pow((t * (t_1 * t_2)), -2.0) * ((t_3 / t_1) / t_2));
} else {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.cbrt(l), -2.0);
double t_2 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_3 = Math.sqrt(2.0) / k;
double tmp;
if (((l * l) <= 1e-271) || !((l * l) <= 1e+213)) {
tmp = (t * t_3) * (Math.pow((t * (t_1 * t_2)), -2.0) * ((t_3 / t_1) / t_2));
} else {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(l) ^ -2.0 t_2 = cbrt(Float64(sin(k) * tan(k))) t_3 = Float64(sqrt(2.0) / k) tmp = 0.0 if ((Float64(l * l) <= 1e-271) || !(Float64(l * l) <= 1e+213)) tmp = Float64(Float64(t * t_3) * Float64((Float64(t * Float64(t_1 * t_2)) ^ -2.0) * Float64(Float64(t_3 / t_1) / t_2))); else tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]}, If[Or[LessEqual[N[(l * l), $MachinePrecision], 1e-271], N[Not[LessEqual[N[(l * l), $MachinePrecision], 1e+213]], $MachinePrecision]], N[(N[(t * t$95$3), $MachinePrecision] * N[(N[Power[N[(t * N[(t$95$1 * t$95$2), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision] * N[(N[(t$95$3 / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t_2 := \sqrt[3]{\sin k \cdot \tan k}\\
t_3 := \frac{\sqrt{2}}{k}\\
\mathbf{if}\;\ell \cdot \ell \leq 10^{-271} \lor \neg \left(\ell \cdot \ell \leq 10^{+213}\right):\\
\;\;\;\;\left(t \cdot t\_3\right) \cdot \left({\left(t \cdot \left(t\_1 \cdot t\_2\right)\right)}^{-2} \cdot \frac{\frac{t\_3}{t\_1}}{t\_2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\end{array}
\end{array}
if (*.f64 l l) < 9.99999999999999963e-272 or 9.99999999999999984e212 < (*.f64 l l) Initial program 30.9%
*-commutative30.9%
associate-/r*30.9%
Simplified37.7%
add-sqr-sqrt37.7%
add-cube-cbrt37.7%
times-frac37.7%
Applied egg-rr85.7%
associate-/r/85.7%
associate-/r*85.7%
associate-/r/85.6%
Simplified85.6%
associate-*r/85.7%
Applied egg-rr85.6%
associate-*r/85.6%
associate-*l*85.1%
associate-*l/85.1%
*-commutative85.1%
associate-*l*85.1%
Simplified86.5%
if 9.99999999999999963e-272 < (*.f64 l l) < 9.99999999999999984e212Initial program 41.4%
*-commutative41.4%
associate-/r*41.5%
Simplified49.0%
add-sqr-sqrt49.0%
add-cube-cbrt48.9%
times-frac48.9%
Applied egg-rr76.3%
associate-/r/76.3%
associate-/r*76.3%
associate-/r/76.4%
Simplified76.4%
Taylor expanded in k around inf 90.3%
times-frac91.9%
*-commutative91.9%
unpow291.9%
rem-square-sqrt92.2%
*-commutative92.2%
times-frac92.2%
Simplified92.2%
Final simplification88.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (cbrt l) -2.0))
(t_2 (cbrt (* (sin k) (tan k))))
(t_3 (* t_2 (/ t (pow (cbrt l) 2.0)))))
(if (<= l 1.55e-146)
(*
(* t (/ (cbrt (pow 2.0 1.5)) k))
(*
(pow (* t (* t_1 t_2)) -2.0)
(/ (/ (/ (sqrt 2.0) k) t_1) (cbrt (pow k 2.0)))))
(if (<= l 1.2e+175)
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))
(* (/ 2.0 (pow t_3 2.0)) (/ (pow (/ k t) -2.0) t_3))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), -2.0);
double t_2 = cbrt((sin(k) * tan(k)));
double t_3 = t_2 * (t / pow(cbrt(l), 2.0));
double tmp;
if (l <= 1.55e-146) {
tmp = (t * (cbrt(pow(2.0, 1.5)) / k)) * (pow((t * (t_1 * t_2)), -2.0) * (((sqrt(2.0) / k) / t_1) / cbrt(pow(k, 2.0))));
} else if (l <= 1.2e+175) {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
} else {
tmp = (2.0 / pow(t_3, 2.0)) * (pow((k / t), -2.0) / t_3);
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.cbrt(l), -2.0);
double t_2 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_3 = t_2 * (t / Math.pow(Math.cbrt(l), 2.0));
double tmp;
if (l <= 1.55e-146) {
tmp = (t * (Math.cbrt(Math.pow(2.0, 1.5)) / k)) * (Math.pow((t * (t_1 * t_2)), -2.0) * (((Math.sqrt(2.0) / k) / t_1) / Math.cbrt(Math.pow(k, 2.0))));
} else if (l <= 1.2e+175) {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
} else {
tmp = (2.0 / Math.pow(t_3, 2.0)) * (Math.pow((k / t), -2.0) / t_3);
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(l) ^ -2.0 t_2 = cbrt(Float64(sin(k) * tan(k))) t_3 = Float64(t_2 * Float64(t / (cbrt(l) ^ 2.0))) tmp = 0.0 if (l <= 1.55e-146) tmp = Float64(Float64(t * Float64(cbrt((2.0 ^ 1.5)) / k)) * Float64((Float64(t * Float64(t_1 * t_2)) ^ -2.0) * Float64(Float64(Float64(sqrt(2.0) / k) / t_1) / cbrt((k ^ 2.0))))); elseif (l <= 1.2e+175) tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); else tmp = Float64(Float64(2.0 / (t_3 ^ 2.0)) * Float64((Float64(k / t) ^ -2.0) / t_3)); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 1.55e-146], N[(N[(t * N[(N[Power[N[Power[2.0, 1.5], $MachinePrecision], 1/3], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t * N[(t$95$1 * t$95$2), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision] * N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision] / t$95$1), $MachinePrecision] / N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 1.2e+175], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[Power[t$95$3, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(k / t), $MachinePrecision], -2.0], $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t_2 := \sqrt[3]{\sin k \cdot \tan k}\\
t_3 := t\_2 \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
\mathbf{if}\;\ell \leq 1.55 \cdot 10^{-146}:\\
\;\;\;\;\left(t \cdot \frac{\sqrt[3]{{2}^{1.5}}}{k}\right) \cdot \left({\left(t \cdot \left(t\_1 \cdot t\_2\right)\right)}^{-2} \cdot \frac{\frac{\frac{\sqrt{2}}{k}}{t\_1}}{\sqrt[3]{{k}^{2}}}\right)\\
\mathbf{elif}\;\ell \leq 1.2 \cdot 10^{+175}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{t\_3}^{2}} \cdot \frac{{\left(\frac{k}{t}\right)}^{-2}}{t\_3}\\
\end{array}
\end{array}
if l < 1.5499999999999999e-146Initial program 34.5%
*-commutative34.5%
associate-/r*34.5%
Simplified42.6%
add-sqr-sqrt42.6%
add-cube-cbrt42.6%
times-frac42.6%
Applied egg-rr80.7%
associate-/r/80.7%
associate-/r*80.7%
associate-/r/80.7%
Simplified80.7%
associate-*r/80.7%
Applied egg-rr81.0%
associate-*r/81.0%
associate-*l*81.0%
associate-*l/81.0%
*-commutative81.0%
associate-*l*81.0%
Simplified82.3%
Taylor expanded in k around 0 71.9%
add-cbrt-cube71.9%
pow1/371.9%
pow1/271.9%
pow1/271.9%
pow-prod-up71.9%
metadata-eval71.9%
metadata-eval71.9%
Applied egg-rr71.9%
unpow1/371.9%
*-commutative71.9%
unpow1/271.9%
pow-plus71.9%
metadata-eval71.9%
Simplified71.9%
if 1.5499999999999999e-146 < l < 1.2e175Initial program 39.6%
*-commutative39.6%
associate-/r*39.6%
Simplified46.8%
add-sqr-sqrt46.8%
add-cube-cbrt46.8%
times-frac46.7%
Applied egg-rr82.1%
associate-/r/82.2%
associate-/r*82.2%
associate-/r/82.2%
Simplified82.2%
Taylor expanded in k around inf 84.3%
times-frac92.3%
*-commutative92.3%
unpow292.3%
rem-square-sqrt92.6%
*-commutative92.6%
times-frac92.6%
Simplified92.6%
if 1.2e175 < l Initial program 26.4%
*-commutative26.4%
associate-/r*26.4%
Simplified26.4%
add-cube-cbrt26.4%
div-inv26.4%
times-frac26.4%
Applied egg-rr78.1%
Final simplification77.1%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (cbrt l) -2.0))
(t_2 (cbrt (* (sin k) (tan k))))
(t_3 (/ (sqrt 2.0) k))
(t_4 (* t_2 (/ t (pow (cbrt l) 2.0)))))
(if (<= l 5e-146)
(*
(* t t_3)
(* (pow (* t (* t_1 t_2)) -2.0) (/ (/ t_3 t_1) (cbrt (pow k 2.0)))))
(if (<= l 1.2e+175)
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))
(* (/ 2.0 (pow t_4 2.0)) (/ (pow (/ k t) -2.0) t_4))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), -2.0);
double t_2 = cbrt((sin(k) * tan(k)));
double t_3 = sqrt(2.0) / k;
double t_4 = t_2 * (t / pow(cbrt(l), 2.0));
double tmp;
if (l <= 5e-146) {
tmp = (t * t_3) * (pow((t * (t_1 * t_2)), -2.0) * ((t_3 / t_1) / cbrt(pow(k, 2.0))));
} else if (l <= 1.2e+175) {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
} else {
tmp = (2.0 / pow(t_4, 2.0)) * (pow((k / t), -2.0) / t_4);
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.cbrt(l), -2.0);
double t_2 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_3 = Math.sqrt(2.0) / k;
double t_4 = t_2 * (t / Math.pow(Math.cbrt(l), 2.0));
double tmp;
if (l <= 5e-146) {
tmp = (t * t_3) * (Math.pow((t * (t_1 * t_2)), -2.0) * ((t_3 / t_1) / Math.cbrt(Math.pow(k, 2.0))));
} else if (l <= 1.2e+175) {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
} else {
tmp = (2.0 / Math.pow(t_4, 2.0)) * (Math.pow((k / t), -2.0) / t_4);
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(l) ^ -2.0 t_2 = cbrt(Float64(sin(k) * tan(k))) t_3 = Float64(sqrt(2.0) / k) t_4 = Float64(t_2 * Float64(t / (cbrt(l) ^ 2.0))) tmp = 0.0 if (l <= 5e-146) tmp = Float64(Float64(t * t_3) * Float64((Float64(t * Float64(t_1 * t_2)) ^ -2.0) * Float64(Float64(t_3 / t_1) / cbrt((k ^ 2.0))))); elseif (l <= 1.2e+175) tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); else tmp = Float64(Float64(2.0 / (t_4 ^ 2.0)) * Float64((Float64(k / t) ^ -2.0) / t_4)); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 5e-146], N[(N[(t * t$95$3), $MachinePrecision] * N[(N[Power[N[(t * N[(t$95$1 * t$95$2), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision] * N[(N[(t$95$3 / t$95$1), $MachinePrecision] / N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 1.2e+175], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[Power[t$95$4, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(k / t), $MachinePrecision], -2.0], $MachinePrecision] / t$95$4), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t_2 := \sqrt[3]{\sin k \cdot \tan k}\\
t_3 := \frac{\sqrt{2}}{k}\\
t_4 := t\_2 \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
\mathbf{if}\;\ell \leq 5 \cdot 10^{-146}:\\
\;\;\;\;\left(t \cdot t\_3\right) \cdot \left({\left(t \cdot \left(t\_1 \cdot t\_2\right)\right)}^{-2} \cdot \frac{\frac{t\_3}{t\_1}}{\sqrt[3]{{k}^{2}}}\right)\\
\mathbf{elif}\;\ell \leq 1.2 \cdot 10^{+175}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{t\_4}^{2}} \cdot \frac{{\left(\frac{k}{t}\right)}^{-2}}{t\_4}\\
\end{array}
\end{array}
if l < 4.99999999999999957e-146Initial program 34.5%
*-commutative34.5%
associate-/r*34.5%
Simplified42.6%
add-sqr-sqrt42.6%
add-cube-cbrt42.6%
times-frac42.6%
Applied egg-rr80.7%
associate-/r/80.7%
associate-/r*80.7%
associate-/r/80.7%
Simplified80.7%
associate-*r/80.7%
Applied egg-rr81.0%
associate-*r/81.0%
associate-*l*81.0%
associate-*l/81.0%
*-commutative81.0%
associate-*l*81.0%
Simplified82.3%
Taylor expanded in k around 0 71.9%
if 4.99999999999999957e-146 < l < 1.2e175Initial program 39.6%
*-commutative39.6%
associate-/r*39.6%
Simplified46.8%
add-sqr-sqrt46.8%
add-cube-cbrt46.8%
times-frac46.7%
Applied egg-rr82.1%
associate-/r/82.2%
associate-/r*82.2%
associate-/r/82.2%
Simplified82.2%
Taylor expanded in k around inf 84.3%
times-frac92.3%
*-commutative92.3%
unpow292.3%
rem-square-sqrt92.6%
*-commutative92.6%
times-frac92.6%
Simplified92.6%
if 1.2e175 < l Initial program 26.4%
*-commutative26.4%
associate-/r*26.4%
Simplified26.4%
add-cube-cbrt26.4%
div-inv26.4%
times-frac26.4%
Applied egg-rr78.1%
Final simplification77.1%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (cbrt l) -2.0))
(t_2 (* (sin k) (tan k)))
(t_3 (/ (sqrt 2.0) k)))
(if (<= l 7.5e-147)
(*
(* t t_3)
(*
(pow (* t (* t_1 (cbrt t_2))) -2.0)
(/ (/ t_3 t_1) (cbrt (pow k 2.0)))))
(if (<= l 1.2e+175)
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))
(/
(* 2.0 (pow (/ k t) -2.0))
(* t_2 (pow (/ t (pow (cbrt l) 2.0)) 3.0)))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), -2.0);
double t_2 = sin(k) * tan(k);
double t_3 = sqrt(2.0) / k;
double tmp;
if (l <= 7.5e-147) {
tmp = (t * t_3) * (pow((t * (t_1 * cbrt(t_2))), -2.0) * ((t_3 / t_1) / cbrt(pow(k, 2.0))));
} else if (l <= 1.2e+175) {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
} else {
tmp = (2.0 * pow((k / t), -2.0)) / (t_2 * pow((t / pow(cbrt(l), 2.0)), 3.0));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.cbrt(l), -2.0);
double t_2 = Math.sin(k) * Math.tan(k);
double t_3 = Math.sqrt(2.0) / k;
double tmp;
if (l <= 7.5e-147) {
tmp = (t * t_3) * (Math.pow((t * (t_1 * Math.cbrt(t_2))), -2.0) * ((t_3 / t_1) / Math.cbrt(Math.pow(k, 2.0))));
} else if (l <= 1.2e+175) {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
} else {
tmp = (2.0 * Math.pow((k / t), -2.0)) / (t_2 * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0));
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(l) ^ -2.0 t_2 = Float64(sin(k) * tan(k)) t_3 = Float64(sqrt(2.0) / k) tmp = 0.0 if (l <= 7.5e-147) tmp = Float64(Float64(t * t_3) * Float64((Float64(t * Float64(t_1 * cbrt(t_2))) ^ -2.0) * Float64(Float64(t_3 / t_1) / cbrt((k ^ 2.0))))); elseif (l <= 1.2e+175) tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); else tmp = Float64(Float64(2.0 * (Float64(k / t) ^ -2.0)) / Float64(t_2 * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]}, If[LessEqual[l, 7.5e-147], N[(N[(t * t$95$3), $MachinePrecision] * N[(N[Power[N[(t * N[(t$95$1 * N[Power[t$95$2, 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision] * N[(N[(t$95$3 / t$95$1), $MachinePrecision] / N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 1.2e+175], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[Power[N[(k / t), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$2 * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t_2 := \sin k \cdot \tan k\\
t_3 := \frac{\sqrt{2}}{k}\\
\mathbf{if}\;\ell \leq 7.5 \cdot 10^{-147}:\\
\;\;\;\;\left(t \cdot t\_3\right) \cdot \left({\left(t \cdot \left(t\_1 \cdot \sqrt[3]{t\_2}\right)\right)}^{-2} \cdot \frac{\frac{t\_3}{t\_1}}{\sqrt[3]{{k}^{2}}}\right)\\
\mathbf{elif}\;\ell \leq 1.2 \cdot 10^{+175}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2 \cdot {\left(\frac{k}{t}\right)}^{-2}}{t\_2 \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}}\\
\end{array}
\end{array}
if l < 7.50000000000000047e-147Initial program 34.5%
*-commutative34.5%
associate-/r*34.5%
Simplified42.6%
add-sqr-sqrt42.6%
add-cube-cbrt42.6%
times-frac42.6%
Applied egg-rr80.7%
associate-/r/80.7%
associate-/r*80.7%
associate-/r/80.7%
Simplified80.7%
associate-*r/80.7%
Applied egg-rr81.0%
associate-*r/81.0%
associate-*l*81.0%
associate-*l/81.0%
*-commutative81.0%
associate-*l*81.0%
Simplified82.3%
Taylor expanded in k around 0 71.9%
if 7.50000000000000047e-147 < l < 1.2e175Initial program 39.6%
*-commutative39.6%
associate-/r*39.6%
Simplified46.8%
add-sqr-sqrt46.8%
add-cube-cbrt46.8%
times-frac46.7%
Applied egg-rr82.1%
associate-/r/82.2%
associate-/r*82.2%
associate-/r/82.2%
Simplified82.2%
Taylor expanded in k around inf 84.3%
times-frac92.3%
*-commutative92.3%
unpow292.3%
rem-square-sqrt92.6%
*-commutative92.6%
times-frac92.6%
Simplified92.6%
if 1.2e175 < l Initial program 26.4%
*-commutative26.4%
associate-/r*26.4%
Simplified26.4%
add-cube-cbrt26.4%
div-inv26.4%
times-frac26.4%
Applied egg-rr78.1%
associate-*l/78.2%
associate-/l*78.2%
associate-/l/70.7%
unpow270.7%
unpow370.7%
*-commutative70.7%
Simplified67.0%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (cbrt l) -2.0))
(t_2 (cbrt (pow k 2.0)))
(t_3 (/ (sqrt 2.0) k)))
(if (<= l 7.8e-147)
(* (* t t_3) (* (/ (/ t_3 t_1) t_2) (pow (* t (* t_1 t_2)) -2.0)))
(if (<= l 1.2e+175)
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))
(/
(* 2.0 (pow (/ k t) -2.0))
(* (* (sin k) (tan k)) (pow (/ t (pow (cbrt l) 2.0)) 3.0)))))))
double code(double t, double l, double k) {
double t_1 = pow(cbrt(l), -2.0);
double t_2 = cbrt(pow(k, 2.0));
double t_3 = sqrt(2.0) / k;
double tmp;
if (l <= 7.8e-147) {
tmp = (t * t_3) * (((t_3 / t_1) / t_2) * pow((t * (t_1 * t_2)), -2.0));
} else if (l <= 1.2e+175) {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
} else {
tmp = (2.0 * pow((k / t), -2.0)) / ((sin(k) * tan(k)) * pow((t / pow(cbrt(l), 2.0)), 3.0));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.cbrt(l), -2.0);
double t_2 = Math.cbrt(Math.pow(k, 2.0));
double t_3 = Math.sqrt(2.0) / k;
double tmp;
if (l <= 7.8e-147) {
tmp = (t * t_3) * (((t_3 / t_1) / t_2) * Math.pow((t * (t_1 * t_2)), -2.0));
} else if (l <= 1.2e+175) {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
} else {
tmp = (2.0 * Math.pow((k / t), -2.0)) / ((Math.sin(k) * Math.tan(k)) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0));
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(l) ^ -2.0 t_2 = cbrt((k ^ 2.0)) t_3 = Float64(sqrt(2.0) / k) tmp = 0.0 if (l <= 7.8e-147) tmp = Float64(Float64(t * t_3) * Float64(Float64(Float64(t_3 / t_1) / t_2) * (Float64(t * Float64(t_1 * t_2)) ^ -2.0))); elseif (l <= 1.2e+175) tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); else tmp = Float64(Float64(2.0 * (Float64(k / t) ^ -2.0)) / Float64(Float64(sin(k) * tan(k)) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$2 = N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]}, If[LessEqual[l, 7.8e-147], N[(N[(t * t$95$3), $MachinePrecision] * N[(N[(N[(t$95$3 / t$95$1), $MachinePrecision] / t$95$2), $MachinePrecision] * N[Power[N[(t * N[(t$95$1 * t$95$2), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 1.2e+175], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[Power[N[(k / t), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t_2 := \sqrt[3]{{k}^{2}}\\
t_3 := \frac{\sqrt{2}}{k}\\
\mathbf{if}\;\ell \leq 7.8 \cdot 10^{-147}:\\
\;\;\;\;\left(t \cdot t\_3\right) \cdot \left(\frac{\frac{t\_3}{t\_1}}{t\_2} \cdot {\left(t \cdot \left(t\_1 \cdot t\_2\right)\right)}^{-2}\right)\\
\mathbf{elif}\;\ell \leq 1.2 \cdot 10^{+175}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2 \cdot {\left(\frac{k}{t}\right)}^{-2}}{\left(\sin k \cdot \tan k\right) \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}}\\
\end{array}
\end{array}
if l < 7.7999999999999996e-147Initial program 34.5%
*-commutative34.5%
associate-/r*34.5%
Simplified42.6%
add-sqr-sqrt42.6%
add-cube-cbrt42.6%
times-frac42.6%
Applied egg-rr80.7%
associate-/r/80.7%
associate-/r*80.7%
associate-/r/80.7%
Simplified80.7%
associate-*r/80.7%
Applied egg-rr81.0%
associate-*r/81.0%
associate-*l*81.0%
associate-*l/81.0%
*-commutative81.0%
associate-*l*81.0%
Simplified82.3%
Taylor expanded in k around 0 71.9%
Taylor expanded in k around 0 72.0%
if 7.7999999999999996e-147 < l < 1.2e175Initial program 39.6%
*-commutative39.6%
associate-/r*39.6%
Simplified46.8%
add-sqr-sqrt46.8%
add-cube-cbrt46.8%
times-frac46.7%
Applied egg-rr82.1%
associate-/r/82.2%
associate-/r*82.2%
associate-/r/82.2%
Simplified82.2%
Taylor expanded in k around inf 84.3%
times-frac92.3%
*-commutative92.3%
unpow292.3%
rem-square-sqrt92.6%
*-commutative92.6%
times-frac92.6%
Simplified92.6%
if 1.2e175 < l Initial program 26.4%
*-commutative26.4%
associate-/r*26.4%
Simplified26.4%
add-cube-cbrt26.4%
div-inv26.4%
times-frac26.4%
Applied egg-rr78.1%
associate-*l/78.2%
associate-/l*78.2%
associate-/l/70.7%
unpow270.7%
unpow370.7%
*-commutative70.7%
Simplified67.0%
Final simplification76.0%
(FPCore (t l k)
:precision binary64
(if (<= k 6.4e-149)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(log (pow (pow (exp (pow t 3.0)) (pow l -2.0)) (* (sin k) (tan k)))))
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))))
double code(double t, double l, double k) {
double tmp;
if (k <= 6.4e-149) {
tmp = (2.0 / ((k / t) / (t / k))) / log(pow(pow(exp(pow(t, 3.0)), pow(l, -2.0)), (sin(k) * tan(k))));
} else {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / 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 <= 6.4d-149) then
tmp = (2.0d0 / ((k / t) / (t / k))) / log(((exp((t ** 3.0d0)) ** (l ** (-2.0d0))) ** (sin(k) * tan(k))))
else
tmp = ((l ** 2.0d0) / (k ** 2.0d0)) * ((2.0d0 / (sin(k) ** 2.0d0)) * (cos(k) / t))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 6.4e-149) {
tmp = (2.0 / ((k / t) / (t / k))) / Math.log(Math.pow(Math.pow(Math.exp(Math.pow(t, 3.0)), Math.pow(l, -2.0)), (Math.sin(k) * Math.tan(k))));
} else {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 6.4e-149: tmp = (2.0 / ((k / t) / (t / k))) / math.log(math.pow(math.pow(math.exp(math.pow(t, 3.0)), math.pow(l, -2.0)), (math.sin(k) * math.tan(k)))) else: tmp = (math.pow(l, 2.0) / math.pow(k, 2.0)) * ((2.0 / math.pow(math.sin(k), 2.0)) * (math.cos(k) / t)) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 6.4e-149) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / log(((exp((t ^ 3.0)) ^ (l ^ -2.0)) ^ Float64(sin(k) * tan(k))))); else tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 6.4e-149) tmp = (2.0 / ((k / t) / (t / k))) / log(((exp((t ^ 3.0)) ^ (l ^ -2.0)) ^ (sin(k) * tan(k)))); else tmp = ((l ^ 2.0) / (k ^ 2.0)) * ((2.0 / (sin(k) ^ 2.0)) * (cos(k) / t)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 6.4e-149], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Log[N[Power[N[Power[N[Exp[N[Power[t, 3.0], $MachinePrecision]], $MachinePrecision], N[Power[l, -2.0], $MachinePrecision]], $MachinePrecision], N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 6.4 \cdot 10^{-149}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\log \left({\left({\left(e^{{t}^{3}}\right)}^{\left({\ell}^{-2}\right)}\right)}^{\left(\sin k \cdot \tan k\right)}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\end{array}
\end{array}
if k < 6.40000000000000004e-149Initial program 32.1%
*-commutative32.1%
associate-/r*32.1%
Simplified36.5%
+-rgt-identity36.5%
unpow236.5%
clear-num36.5%
un-div-inv36.5%
Applied egg-rr36.5%
add-log-exp23.9%
exp-prod30.8%
div-inv30.8%
exp-prod27.2%
pow227.2%
pow-flip27.2%
metadata-eval27.2%
Applied egg-rr27.2%
if 6.40000000000000004e-149 < k Initial program 39.3%
*-commutative39.3%
associate-/r*39.3%
Simplified50.8%
add-sqr-sqrt50.8%
add-cube-cbrt50.8%
times-frac50.8%
Applied egg-rr83.9%
associate-/r/83.9%
associate-/r*83.9%
associate-/r/83.9%
Simplified83.9%
Taylor expanded in k around inf 81.3%
times-frac80.7%
*-commutative80.7%
unpow280.7%
rem-square-sqrt80.8%
*-commutative80.8%
times-frac80.7%
Simplified80.7%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* (* (sin k) (tan k)) (pow (/ t (pow (cbrt l) 2.0)) 3.0))))
(if (<= l 1.15e-171)
(/ (/ 2.0 (/ (/ k t) (/ t k))) t_1)
(if (<= l 1.2e+175)
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))
(/ (* 2.0 (pow (/ k t) -2.0)) t_1)))))
double code(double t, double l, double k) {
double t_1 = (sin(k) * tan(k)) * pow((t / pow(cbrt(l), 2.0)), 3.0);
double tmp;
if (l <= 1.15e-171) {
tmp = (2.0 / ((k / t) / (t / k))) / t_1;
} else if (l <= 1.2e+175) {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
} else {
tmp = (2.0 * pow((k / t), -2.0)) / t_1;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = (Math.sin(k) * Math.tan(k)) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0);
double tmp;
if (l <= 1.15e-171) {
tmp = (2.0 / ((k / t) / (t / k))) / t_1;
} else if (l <= 1.2e+175) {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
} else {
tmp = (2.0 * Math.pow((k / t), -2.0)) / t_1;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(Float64(sin(k) * tan(k)) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)) tmp = 0.0 if (l <= 1.15e-171) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / t_1); elseif (l <= 1.2e+175) tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); else tmp = Float64(Float64(2.0 * (Float64(k / t) ^ -2.0)) / t_1); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 1.15e-171], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[l, 1.2e+175], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[Power[N[(k / t), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\sin k \cdot \tan k\right) \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\\
\mathbf{if}\;\ell \leq 1.15 \cdot 10^{-171}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{t\_1}\\
\mathbf{elif}\;\ell \leq 1.2 \cdot 10^{+175}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2 \cdot {\left(\frac{k}{t}\right)}^{-2}}{t\_1}\\
\end{array}
\end{array}
if l < 1.14999999999999989e-171Initial program 34.9%
*-commutative34.9%
associate-/r*34.9%
Simplified42.8%
+-rgt-identity42.8%
unpow242.8%
clear-num42.8%
un-div-inv42.8%
Applied egg-rr42.8%
add-cube-cbrt42.8%
associate-*l*42.8%
cbrt-div42.8%
rem-cbrt-cube42.8%
cbrt-prod42.8%
pow242.8%
pow242.8%
cbrt-div42.7%
rem-cbrt-cube53.1%
cbrt-prod62.8%
pow262.8%
Applied egg-rr62.8%
unpow262.8%
cube-mult62.8%
Simplified62.8%
if 1.14999999999999989e-171 < l < 1.2e175Initial program 37.8%
*-commutative37.8%
associate-/r*37.8%
Simplified45.8%
add-sqr-sqrt45.8%
add-cube-cbrt45.7%
times-frac45.7%
Applied egg-rr81.3%
associate-/r/81.3%
associate-/r*81.3%
associate-/r/81.4%
Simplified81.4%
Taylor expanded in k around inf 82.8%
times-frac88.5%
*-commutative88.5%
unpow288.5%
rem-square-sqrt88.7%
*-commutative88.7%
times-frac88.7%
Simplified88.7%
if 1.2e175 < l Initial program 26.4%
*-commutative26.4%
associate-/r*26.4%
Simplified26.4%
add-cube-cbrt26.4%
div-inv26.4%
times-frac26.4%
Applied egg-rr78.1%
associate-*l/78.2%
associate-/l*78.2%
associate-/l/70.7%
unpow270.7%
unpow370.7%
*-commutative70.7%
Simplified67.0%
Final simplification69.7%
(FPCore (t l k)
:precision binary64
(if (<= k 2.7e-148)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(pow (* (cbrt (* (sin k) (tan k))) (/ t (pow (cbrt l) 2.0))) 3.0))
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t)))))
double code(double t, double l, double k) {
double tmp;
if (k <= 2.7e-148) {
tmp = (2.0 / ((k / t) / (t / k))) / pow((cbrt((sin(k) * tan(k))) * (t / pow(cbrt(l), 2.0))), 3.0);
} else {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / t));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (k <= 2.7e-148) {
tmp = (2.0 / ((k / t) / (t / k))) / Math.pow((Math.cbrt((Math.sin(k) * Math.tan(k))) * (t / Math.pow(Math.cbrt(l), 2.0))), 3.0);
} else {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (k <= 2.7e-148) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / (Float64(cbrt(Float64(sin(k) * tan(k))) * Float64(t / (cbrt(l) ^ 2.0))) ^ 3.0)); else tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); end return tmp end
code[t_, l_, k_] := If[LessEqual[k, 2.7e-148], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[(N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 2.7 \cdot 10^{-148}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{{\left(\sqrt[3]{\sin k \cdot \tan k} \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\end{array}
\end{array}
if k < 2.69999999999999988e-148Initial program 32.1%
*-commutative32.1%
associate-/r*32.1%
Simplified36.5%
+-rgt-identity36.5%
unpow236.5%
clear-num36.5%
un-div-inv36.5%
Applied egg-rr36.5%
add-cube-cbrt36.5%
pow336.5%
cbrt-prod36.4%
cbrt-div38.8%
rem-cbrt-cube56.0%
cbrt-prod66.5%
pow266.5%
Applied egg-rr66.5%
if 2.69999999999999988e-148 < k Initial program 39.3%
*-commutative39.3%
associate-/r*39.3%
Simplified50.8%
add-sqr-sqrt50.8%
add-cube-cbrt50.8%
times-frac50.8%
Applied egg-rr83.9%
associate-/r/83.9%
associate-/r*83.9%
associate-/r/83.9%
Simplified83.9%
Taylor expanded in k around inf 81.3%
times-frac80.7%
*-commutative80.7%
unpow280.7%
rem-square-sqrt80.8%
*-commutative80.8%
times-frac80.7%
Simplified80.7%
Final simplification71.8%
(FPCore (t l k)
:precision binary64
(if (<= t 2.95e-98)
(* (cos k) (* 2.0 (/ (/ (pow l 2.0) t) (pow (* k (sin k)) 2.0))))
(if (<= t 2.8e+85)
(/
(* (/ t k) (/ 2.0 (/ k t)))
(/ (* (* (sin k) (tan k)) (/ (pow t 3.0) l)) l))
(*
(/ (pow l 2.0) (pow k 2.0))
(* (/ 2.0 (pow (sin k) 2.0)) (/ (cos k) t))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 2.95e-98) {
tmp = cos(k) * (2.0 * ((pow(l, 2.0) / t) / pow((k * sin(k)), 2.0)));
} else if (t <= 2.8e+85) {
tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * (pow(t, 3.0) / l)) / l);
} else {
tmp = (pow(l, 2.0) / pow(k, 2.0)) * ((2.0 / pow(sin(k), 2.0)) * (cos(k) / 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 (t <= 2.95d-98) then
tmp = cos(k) * (2.0d0 * (((l ** 2.0d0) / t) / ((k * sin(k)) ** 2.0d0)))
else if (t <= 2.8d+85) then
tmp = ((t / k) * (2.0d0 / (k / t))) / (((sin(k) * tan(k)) * ((t ** 3.0d0) / l)) / l)
else
tmp = ((l ** 2.0d0) / (k ** 2.0d0)) * ((2.0d0 / (sin(k) ** 2.0d0)) * (cos(k) / t))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 2.95e-98) {
tmp = Math.cos(k) * (2.0 * ((Math.pow(l, 2.0) / t) / Math.pow((k * Math.sin(k)), 2.0)));
} else if (t <= 2.8e+85) {
tmp = ((t / k) * (2.0 / (k / t))) / (((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / l)) / l);
} else {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) * ((2.0 / Math.pow(Math.sin(k), 2.0)) * (Math.cos(k) / t));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 2.95e-98: tmp = math.cos(k) * (2.0 * ((math.pow(l, 2.0) / t) / math.pow((k * math.sin(k)), 2.0))) elif t <= 2.8e+85: tmp = ((t / k) * (2.0 / (k / t))) / (((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / l)) / l) else: tmp = (math.pow(l, 2.0) / math.pow(k, 2.0)) * ((2.0 / math.pow(math.sin(k), 2.0)) * (math.cos(k) / t)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 2.95e-98) tmp = Float64(cos(k) * Float64(2.0 * Float64(Float64((l ^ 2.0) / t) / (Float64(k * sin(k)) ^ 2.0)))); elseif (t <= 2.8e+85) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 / Float64(k / t))) / Float64(Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / l)) / l)); else tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) * Float64(Float64(2.0 / (sin(k) ^ 2.0)) * Float64(cos(k) / t))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 2.95e-98) tmp = cos(k) * (2.0 * (((l ^ 2.0) / t) / ((k * sin(k)) ^ 2.0))); elseif (t <= 2.8e+85) tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * ((t ^ 3.0) / l)) / l); else tmp = ((l ^ 2.0) / (k ^ 2.0)) * ((2.0 / (sin(k) ^ 2.0)) * (cos(k) / t)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 2.95e-98], N[(N[Cos[k], $MachinePrecision] * N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / t), $MachinePrecision] / N[Power[N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.8e+85], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 / N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 2.95 \cdot 10^{-98}:\\
\;\;\;\;\cos k \cdot \left(2 \cdot \frac{\frac{{\ell}^{2}}{t}}{{\left(k \cdot \sin k\right)}^{2}}\right)\\
\mathbf{elif}\;t \leq 2.8 \cdot 10^{+85}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \frac{2}{\frac{k}{t}}}{\frac{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2}} \cdot \left(\frac{2}{{\sin k}^{2}} \cdot \frac{\cos k}{t}\right)\\
\end{array}
\end{array}
if t < 2.94999999999999996e-98Initial program 32.3%
*-commutative32.3%
associate-/r*32.3%
Simplified38.4%
add-sqr-sqrt38.4%
add-cube-cbrt38.4%
times-frac38.4%
Applied egg-rr81.4%
associate-/r/81.4%
associate-/r*81.4%
associate-/r/81.4%
Simplified81.4%
associate-*r/81.4%
Applied egg-rr81.7%
associate-*r/81.7%
associate-*l*81.5%
associate-*l/81.5%
*-commutative81.5%
associate-*l*81.5%
Simplified82.7%
Taylor expanded in t around 0 75.9%
associate-*r*75.9%
unpow275.9%
rem-square-sqrt76.0%
associate-*l/76.0%
*-commutative76.0%
*-commutative76.0%
associate-/l*76.0%
associate-*r*76.0%
*-commutative76.0%
Simplified76.0%
Taylor expanded in k around inf 76.0%
*-commutative76.0%
*-commutative76.0%
associate-*l*75.4%
unpow275.4%
unpow275.4%
swap-sqr75.4%
unpow275.4%
*-commutative75.4%
associate-*l/75.5%
*-commutative75.5%
associate-*l*75.5%
Simplified73.7%
if 2.94999999999999996e-98 < t < 2.7999999999999999e85Initial program 69.8%
*-commutative69.8%
associate-/r*69.8%
Simplified69.8%
+-rgt-identity69.8%
unpow269.8%
clear-num69.8%
un-div-inv69.8%
Applied egg-rr69.8%
associate-/r/69.9%
Applied egg-rr69.9%
associate-/r*77.4%
associate-*l/80.0%
Applied egg-rr80.0%
if 2.7999999999999999e85 < t Initial program 10.5%
*-commutative10.5%
associate-/r*10.5%
Simplified28.9%
add-sqr-sqrt28.9%
add-cube-cbrt28.9%
times-frac28.9%
Applied egg-rr76.6%
associate-/r/76.6%
associate-/r*76.6%
associate-/r/76.7%
Simplified76.7%
Taylor expanded in k around inf 69.8%
times-frac68.0%
*-commutative68.0%
unpow268.0%
rem-square-sqrt68.1%
*-commutative68.1%
times-frac68.0%
Simplified68.0%
Final simplification73.8%
(FPCore (t l k)
:precision binary64
(if (<= t 2.8e-98)
(* (cos k) (* 2.0 (/ (/ (pow l 2.0) t) (pow (* k (sin k)) 2.0))))
(if (<= t 8e+86)
(/
(* (/ t k) (/ 2.0 (/ k t)))
(/ (* (* (sin k) (tan k)) (/ (pow t 3.0) l)) l))
(* (* l l) (* 2.0 (/ (/ (cos k) (pow k 2.0)) (* t (pow (sin k) 2.0))))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 2.8e-98) {
tmp = cos(k) * (2.0 * ((pow(l, 2.0) / t) / pow((k * sin(k)), 2.0)));
} else if (t <= 8e+86) {
tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * (pow(t, 3.0) / l)) / l);
} else {
tmp = (l * l) * (2.0 * ((cos(k) / pow(k, 2.0)) / (t * pow(sin(k), 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.8d-98) then
tmp = cos(k) * (2.0d0 * (((l ** 2.0d0) / t) / ((k * sin(k)) ** 2.0d0)))
else if (t <= 8d+86) then
tmp = ((t / k) * (2.0d0 / (k / t))) / (((sin(k) * tan(k)) * ((t ** 3.0d0) / l)) / l)
else
tmp = (l * l) * (2.0d0 * ((cos(k) / (k ** 2.0d0)) / (t * (sin(k) ** 2.0d0))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 2.8e-98) {
tmp = Math.cos(k) * (2.0 * ((Math.pow(l, 2.0) / t) / Math.pow((k * Math.sin(k)), 2.0)));
} else if (t <= 8e+86) {
tmp = ((t / k) * (2.0 / (k / t))) / (((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / l)) / l);
} else {
tmp = (l * l) * (2.0 * ((Math.cos(k) / Math.pow(k, 2.0)) / (t * Math.pow(Math.sin(k), 2.0))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 2.8e-98: tmp = math.cos(k) * (2.0 * ((math.pow(l, 2.0) / t) / math.pow((k * math.sin(k)), 2.0))) elif t <= 8e+86: tmp = ((t / k) * (2.0 / (k / t))) / (((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / l)) / l) else: tmp = (l * l) * (2.0 * ((math.cos(k) / math.pow(k, 2.0)) / (t * math.pow(math.sin(k), 2.0)))) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 2.8e-98) tmp = Float64(cos(k) * Float64(2.0 * Float64(Float64((l ^ 2.0) / t) / (Float64(k * sin(k)) ^ 2.0)))); elseif (t <= 8e+86) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 / Float64(k / t))) / Float64(Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / l)) / l)); else tmp = Float64(Float64(l * l) * Float64(2.0 * Float64(Float64(cos(k) / (k ^ 2.0)) / Float64(t * (sin(k) ^ 2.0))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 2.8e-98) tmp = cos(k) * (2.0 * (((l ^ 2.0) / t) / ((k * sin(k)) ^ 2.0))); elseif (t <= 8e+86) tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * ((t ^ 3.0) / l)) / l); else tmp = (l * l) * (2.0 * ((cos(k) / (k ^ 2.0)) / (t * (sin(k) ^ 2.0)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 2.8e-98], N[(N[Cos[k], $MachinePrecision] * N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / t), $MachinePrecision] / N[Power[N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e+86], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 / N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 2.8 \cdot 10^{-98}:\\
\;\;\;\;\cos k \cdot \left(2 \cdot \frac{\frac{{\ell}^{2}}{t}}{{\left(k \cdot \sin k\right)}^{2}}\right)\\
\mathbf{elif}\;t \leq 8 \cdot 10^{+86}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \frac{2}{\frac{k}{t}}}{\frac{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(2 \cdot \frac{\frac{\cos k}{{k}^{2}}}{t \cdot {\sin k}^{2}}\right)\\
\end{array}
\end{array}
if t < 2.7999999999999999e-98Initial program 32.3%
*-commutative32.3%
associate-/r*32.3%
Simplified38.4%
add-sqr-sqrt38.4%
add-cube-cbrt38.4%
times-frac38.4%
Applied egg-rr81.4%
associate-/r/81.4%
associate-/r*81.4%
associate-/r/81.4%
Simplified81.4%
associate-*r/81.4%
Applied egg-rr81.7%
associate-*r/81.7%
associate-*l*81.5%
associate-*l/81.5%
*-commutative81.5%
associate-*l*81.5%
Simplified82.7%
Taylor expanded in t around 0 75.9%
associate-*r*75.9%
unpow275.9%
rem-square-sqrt76.0%
associate-*l/76.0%
*-commutative76.0%
*-commutative76.0%
associate-/l*76.0%
associate-*r*76.0%
*-commutative76.0%
Simplified76.0%
Taylor expanded in k around inf 76.0%
*-commutative76.0%
*-commutative76.0%
associate-*l*75.4%
unpow275.4%
unpow275.4%
swap-sqr75.4%
unpow275.4%
*-commutative75.4%
associate-*l/75.5%
*-commutative75.5%
associate-*l*75.5%
Simplified73.7%
if 2.7999999999999999e-98 < t < 8.0000000000000001e86Initial program 69.8%
*-commutative69.8%
associate-/r*69.8%
Simplified69.8%
+-rgt-identity69.8%
unpow269.8%
clear-num69.8%
un-div-inv69.8%
Applied egg-rr69.8%
associate-/r/69.9%
Applied egg-rr69.9%
associate-/r*77.4%
associate-*l/80.0%
Applied egg-rr80.0%
if 8.0000000000000001e86 < t Initial program 10.5%
Simplified31.6%
Taylor expanded in t around 0 69.9%
associate-/r*70.0%
Simplified70.0%
Final simplification74.1%
(FPCore (t l k)
:precision binary64
(if (or (<= t 2.35e-97) (not (<= t 2.9e+84)))
(* 2.0 (* (cos k) (/ (pow l 2.0) (* t (pow (* k (sin k)) 2.0)))))
(/
(* (/ t k) (/ 2.0 (/ k t)))
(/ (* (* (sin k) (tan k)) (/ (pow t 3.0) l)) l))))
double code(double t, double l, double k) {
double tmp;
if ((t <= 2.35e-97) || !(t <= 2.9e+84)) {
tmp = 2.0 * (cos(k) * (pow(l, 2.0) / (t * pow((k * sin(k)), 2.0))));
} else {
tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * (pow(t, 3.0) / l)) / 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 <= 2.35d-97) .or. (.not. (t <= 2.9d+84))) then
tmp = 2.0d0 * (cos(k) * ((l ** 2.0d0) / (t * ((k * sin(k)) ** 2.0d0))))
else
tmp = ((t / k) * (2.0d0 / (k / t))) / (((sin(k) * tan(k)) * ((t ** 3.0d0) / l)) / l)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= 2.35e-97) || !(t <= 2.9e+84)) {
tmp = 2.0 * (Math.cos(k) * (Math.pow(l, 2.0) / (t * Math.pow((k * Math.sin(k)), 2.0))));
} else {
tmp = ((t / k) * (2.0 / (k / t))) / (((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / l)) / l);
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= 2.35e-97) or not (t <= 2.9e+84): tmp = 2.0 * (math.cos(k) * (math.pow(l, 2.0) / (t * math.pow((k * math.sin(k)), 2.0)))) else: tmp = ((t / k) * (2.0 / (k / t))) / (((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / l)) / l) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= 2.35e-97) || !(t <= 2.9e+84)) tmp = Float64(2.0 * Float64(cos(k) * Float64((l ^ 2.0) / Float64(t * (Float64(k * sin(k)) ^ 2.0))))); else tmp = Float64(Float64(Float64(t / k) * Float64(2.0 / Float64(k / t))) / Float64(Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / l)) / l)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= 2.35e-97) || ~((t <= 2.9e+84))) tmp = 2.0 * (cos(k) * ((l ^ 2.0) / (t * ((k * sin(k)) ^ 2.0)))); else tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * ((t ^ 3.0) / l)) / l); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, 2.35e-97], N[Not[LessEqual[t, 2.9e+84]], $MachinePrecision]], N[(2.0 * N[(N[Cos[k], $MachinePrecision] * N[(N[Power[l, 2.0], $MachinePrecision] / N[(t * N[Power[N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 / N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 2.35 \cdot 10^{-97} \lor \neg \left(t \leq 2.9 \cdot 10^{+84}\right):\\
\;\;\;\;2 \cdot \left(\cos k \cdot \frac{{\ell}^{2}}{t \cdot {\left(k \cdot \sin k\right)}^{2}}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \frac{2}{\frac{k}{t}}}{\frac{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\end{array}
\end{array}
if t < 2.3500000000000001e-97 or 2.89999999999999989e84 < t Initial program 28.5%
*-commutative28.5%
associate-/r*28.5%
Simplified36.8%
add-sqr-sqrt36.8%
add-cube-cbrt36.7%
times-frac36.7%
Applied egg-rr80.5%
associate-/r/80.5%
associate-/r*80.6%
associate-/r/80.6%
Simplified80.6%
associate-*r/80.6%
Applied egg-rr80.8%
associate-*r/80.8%
associate-*l*80.6%
associate-*l/80.6%
*-commutative80.6%
associate-*l*80.6%
Simplified81.7%
Taylor expanded in t around 0 74.8%
associate-*r*74.9%
unpow274.9%
rem-square-sqrt75.0%
associate-*l/75.0%
*-commutative75.0%
*-commutative75.0%
associate-/l*75.0%
associate-*r*75.0%
*-commutative75.0%
Simplified75.0%
Taylor expanded in k around inf 75.0%
*-commutative75.0%
associate-*l*73.6%
unpow273.6%
unpow273.6%
swap-sqr73.6%
unpow273.6%
*-commutative73.6%
Simplified73.6%
if 2.3500000000000001e-97 < t < 2.89999999999999989e84Initial program 69.8%
*-commutative69.8%
associate-/r*69.8%
Simplified69.8%
+-rgt-identity69.8%
unpow269.8%
clear-num69.8%
un-div-inv69.8%
Applied egg-rr69.8%
associate-/r/69.9%
Applied egg-rr69.9%
associate-/r*77.4%
associate-*l/80.0%
Applied egg-rr80.0%
Final simplification74.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (* k (sin k)) 2.0)))
(if (<= t 2.35e-97)
(* (cos k) (* 2.0 (/ (/ (pow l 2.0) t) t_1)))
(if (<= t 1e+88)
(/
(* (/ t k) (/ 2.0 (/ k t)))
(/ (* (* (sin k) (tan k)) (/ (pow t 3.0) l)) l))
(* 2.0 (/ (* (pow l 2.0) (cos k)) (* t t_1)))))))
double code(double t, double l, double k) {
double t_1 = pow((k * sin(k)), 2.0);
double tmp;
if (t <= 2.35e-97) {
tmp = cos(k) * (2.0 * ((pow(l, 2.0) / t) / t_1));
} else if (t <= 1e+88) {
tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * (pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k)) / (t * t_1));
}
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) :: t_1
real(8) :: tmp
t_1 = (k * sin(k)) ** 2.0d0
if (t <= 2.35d-97) then
tmp = cos(k) * (2.0d0 * (((l ** 2.0d0) / t) / t_1))
else if (t <= 1d+88) then
tmp = ((t / k) * (2.0d0 / (k / t))) / (((sin(k) * tan(k)) * ((t ** 3.0d0) / l)) / l)
else
tmp = 2.0d0 * (((l ** 2.0d0) * cos(k)) / (t * t_1))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k * Math.sin(k)), 2.0);
double tmp;
if (t <= 2.35e-97) {
tmp = Math.cos(k) * (2.0 * ((Math.pow(l, 2.0) / t) / t_1));
} else if (t <= 1e+88) {
tmp = ((t / k) * (2.0 / (k / t))) / (((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k)) / (t * t_1));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow((k * math.sin(k)), 2.0) tmp = 0 if t <= 2.35e-97: tmp = math.cos(k) * (2.0 * ((math.pow(l, 2.0) / t) / t_1)) elif t <= 1e+88: tmp = ((t / k) * (2.0 / (k / t))) / (((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / l)) / l) else: tmp = 2.0 * ((math.pow(l, 2.0) * math.cos(k)) / (t * t_1)) return tmp
function code(t, l, k) t_1 = Float64(k * sin(k)) ^ 2.0 tmp = 0.0 if (t <= 2.35e-97) tmp = Float64(cos(k) * Float64(2.0 * Float64(Float64((l ^ 2.0) / t) / t_1))); elseif (t <= 1e+88) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 / Float64(k / t))) / Float64(Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / l)) / l)); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k)) / Float64(t * t_1))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (k * sin(k)) ^ 2.0; tmp = 0.0; if (t <= 2.35e-97) tmp = cos(k) * (2.0 * (((l ^ 2.0) / t) / t_1)); elseif (t <= 1e+88) tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * ((t ^ 3.0) / l)) / l); else tmp = 2.0 * (((l ^ 2.0) * cos(k)) / (t * t_1)); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[t, 2.35e-97], N[(N[Cos[k], $MachinePrecision] * N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / t), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1e+88], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 / N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[(t * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(k \cdot \sin k\right)}^{2}\\
\mathbf{if}\;t \leq 2.35 \cdot 10^{-97}:\\
\;\;\;\;\cos k \cdot \left(2 \cdot \frac{\frac{{\ell}^{2}}{t}}{t\_1}\right)\\
\mathbf{elif}\;t \leq 10^{+88}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \frac{2}{\frac{k}{t}}}{\frac{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k}{t \cdot t\_1}\\
\end{array}
\end{array}
if t < 2.3500000000000001e-97Initial program 32.3%
*-commutative32.3%
associate-/r*32.3%
Simplified38.4%
add-sqr-sqrt38.4%
add-cube-cbrt38.4%
times-frac38.4%
Applied egg-rr81.4%
associate-/r/81.4%
associate-/r*81.4%
associate-/r/81.4%
Simplified81.4%
associate-*r/81.4%
Applied egg-rr81.7%
associate-*r/81.7%
associate-*l*81.5%
associate-*l/81.5%
*-commutative81.5%
associate-*l*81.5%
Simplified82.7%
Taylor expanded in t around 0 75.9%
associate-*r*75.9%
unpow275.9%
rem-square-sqrt76.0%
associate-*l/76.0%
*-commutative76.0%
*-commutative76.0%
associate-/l*76.0%
associate-*r*76.0%
*-commutative76.0%
Simplified76.0%
Taylor expanded in k around inf 76.0%
*-commutative76.0%
*-commutative76.0%
associate-*l*75.4%
unpow275.4%
unpow275.4%
swap-sqr75.4%
unpow275.4%
*-commutative75.4%
associate-*l/75.5%
*-commutative75.5%
associate-*l*75.5%
Simplified73.7%
if 2.3500000000000001e-97 < t < 9.99999999999999959e87Initial program 69.8%
*-commutative69.8%
associate-/r*69.8%
Simplified69.8%
+-rgt-identity69.8%
unpow269.8%
clear-num69.8%
un-div-inv69.8%
Applied egg-rr69.8%
associate-/r/69.9%
Applied egg-rr69.9%
associate-/r*77.4%
associate-*l/80.0%
Applied egg-rr80.0%
if 9.99999999999999959e87 < t Initial program 10.5%
*-commutative10.5%
associate-/r*10.5%
Simplified28.9%
add-sqr-sqrt28.9%
add-cube-cbrt28.9%
times-frac28.9%
Applied egg-rr76.6%
associate-/r/76.6%
associate-/r*76.6%
associate-/r/76.7%
Simplified76.7%
associate-*r/76.7%
Applied egg-rr76.6%
associate-*r/76.6%
associate-*l*76.6%
associate-*l/76.7%
*-commutative76.7%
associate-*l*76.8%
Simplified76.9%
Taylor expanded in t around 0 69.8%
associate-*r*69.8%
unpow269.8%
rem-square-sqrt70.0%
associate-*l/70.0%
*-commutative70.0%
*-commutative70.0%
associate-/l*70.0%
associate-*r*69.9%
*-commutative69.9%
Simplified69.9%
pow269.9%
associate-*r/70.0%
pow270.0%
associate-*r*65.1%
pow-prod-down65.1%
Applied egg-rr65.1%
Final simplification73.4%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* t (pow (* k (sin k)) 2.0))))
(if (<= t 6.2e-99)
(* 2.0 (* (cos k) (/ (pow l 2.0) t_1)))
(if (<= t 7e+90)
(/
(* (/ t k) (/ 2.0 (/ k t)))
(/ (* (* (sin k) (tan k)) (/ (pow t 3.0) l)) l))
(* 2.0 (/ (* (pow l 2.0) (cos k)) t_1))))))
double code(double t, double l, double k) {
double t_1 = t * pow((k * sin(k)), 2.0);
double tmp;
if (t <= 6.2e-99) {
tmp = 2.0 * (cos(k) * (pow(l, 2.0) / t_1));
} else if (t <= 7e+90) {
tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * (pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 * ((pow(l, 2.0) * cos(k)) / t_1);
}
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) :: t_1
real(8) :: tmp
t_1 = t * ((k * sin(k)) ** 2.0d0)
if (t <= 6.2d-99) then
tmp = 2.0d0 * (cos(k) * ((l ** 2.0d0) / t_1))
else if (t <= 7d+90) then
tmp = ((t / k) * (2.0d0 / (k / t))) / (((sin(k) * tan(k)) * ((t ** 3.0d0) / l)) / l)
else
tmp = 2.0d0 * (((l ** 2.0d0) * cos(k)) / t_1)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = t * Math.pow((k * Math.sin(k)), 2.0);
double tmp;
if (t <= 6.2e-99) {
tmp = 2.0 * (Math.cos(k) * (Math.pow(l, 2.0) / t_1));
} else if (t <= 7e+90) {
tmp = ((t / k) * (2.0 / (k / t))) / (((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k)) / t_1);
}
return tmp;
}
def code(t, l, k): t_1 = t * math.pow((k * math.sin(k)), 2.0) tmp = 0 if t <= 6.2e-99: tmp = 2.0 * (math.cos(k) * (math.pow(l, 2.0) / t_1)) elif t <= 7e+90: tmp = ((t / k) * (2.0 / (k / t))) / (((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / l)) / l) else: tmp = 2.0 * ((math.pow(l, 2.0) * math.cos(k)) / t_1) return tmp
function code(t, l, k) t_1 = Float64(t * (Float64(k * sin(k)) ^ 2.0)) tmp = 0.0 if (t <= 6.2e-99) tmp = Float64(2.0 * Float64(cos(k) * Float64((l ^ 2.0) / t_1))); elseif (t <= 7e+90) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 / Float64(k / t))) / Float64(Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / l)) / l)); else tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k)) / t_1)); end return tmp end
function tmp_2 = code(t, l, k) t_1 = t * ((k * sin(k)) ^ 2.0); tmp = 0.0; if (t <= 6.2e-99) tmp = 2.0 * (cos(k) * ((l ^ 2.0) / t_1)); elseif (t <= 7e+90) tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * ((t ^ 3.0) / l)) / l); else tmp = 2.0 * (((l ^ 2.0) * cos(k)) / t_1); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(t * N[Power[N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 6.2e-99], N[(2.0 * N[(N[Cos[k], $MachinePrecision] * N[(N[Power[l, 2.0], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7e+90], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 / N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot {\left(k \cdot \sin k\right)}^{2}\\
\mathbf{if}\;t \leq 6.2 \cdot 10^{-99}:\\
\;\;\;\;2 \cdot \left(\cos k \cdot \frac{{\ell}^{2}}{t\_1}\right)\\
\mathbf{elif}\;t \leq 7 \cdot 10^{+90}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \frac{2}{\frac{k}{t}}}{\frac{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k}{t\_1}\\
\end{array}
\end{array}
if t < 6.1999999999999997e-99Initial program 32.3%
*-commutative32.3%
associate-/r*32.3%
Simplified38.4%
add-sqr-sqrt38.4%
add-cube-cbrt38.4%
times-frac38.4%
Applied egg-rr81.4%
associate-/r/81.4%
associate-/r*81.4%
associate-/r/81.4%
Simplified81.4%
associate-*r/81.4%
Applied egg-rr81.7%
associate-*r/81.7%
associate-*l*81.5%
associate-*l/81.5%
*-commutative81.5%
associate-*l*81.5%
Simplified82.7%
Taylor expanded in t around 0 75.9%
associate-*r*75.9%
unpow275.9%
rem-square-sqrt76.0%
associate-*l/76.0%
*-commutative76.0%
*-commutative76.0%
associate-/l*76.0%
associate-*r*76.0%
*-commutative76.0%
Simplified76.0%
Taylor expanded in k around inf 76.0%
*-commutative76.0%
associate-*l*75.5%
unpow275.5%
unpow275.5%
swap-sqr75.5%
unpow275.5%
*-commutative75.5%
Simplified75.5%
if 6.1999999999999997e-99 < t < 6.9999999999999997e90Initial program 69.8%
*-commutative69.8%
associate-/r*69.8%
Simplified69.8%
+-rgt-identity69.8%
unpow269.8%
clear-num69.8%
un-div-inv69.8%
Applied egg-rr69.8%
associate-/r/69.9%
Applied egg-rr69.9%
associate-/r*77.4%
associate-*l/80.0%
Applied egg-rr80.0%
if 6.9999999999999997e90 < t Initial program 10.5%
*-commutative10.5%
associate-/r*10.5%
Simplified28.9%
add-sqr-sqrt28.9%
add-cube-cbrt28.9%
times-frac28.9%
Applied egg-rr76.6%
associate-/r/76.6%
associate-/r*76.6%
associate-/r/76.7%
Simplified76.7%
associate-*r/76.7%
Applied egg-rr76.6%
associate-*r/76.6%
associate-*l*76.6%
associate-*l/76.7%
*-commutative76.7%
associate-*l*76.8%
Simplified76.9%
Taylor expanded in t around 0 69.8%
associate-*r*69.8%
unpow269.8%
rem-square-sqrt70.0%
associate-*l/70.0%
*-commutative70.0%
*-commutative70.0%
associate-/l*70.0%
associate-*r*69.9%
*-commutative69.9%
Simplified69.9%
pow269.9%
associate-*r/70.0%
pow270.0%
associate-*r*65.1%
pow-prod-down65.1%
Applied egg-rr65.1%
Final simplification74.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* (sin k) (tan k))))
(if (<= t 1.35e-167)
(* 2.0 (/ (/ (pow l 2.0) t) (pow k 4.0)))
(if (<= t 1.3e-90)
(/ (* (/ t k) (/ 2.0 (/ k t))) (* t_1 (* (/ (pow t 2.0) l) (/ t l))))
(if (<= t 2e+95)
(/ (/ 2.0 (/ (/ k t) (/ t k))) (/ (/ (* t_1 (pow t 3.0)) l) l))
(* 2.0 (/ (pow l 2.0) (* t (pow k 4.0)))))))))
double code(double t, double l, double k) {
double t_1 = sin(k) * tan(k);
double tmp;
if (t <= 1.35e-167) {
tmp = 2.0 * ((pow(l, 2.0) / t) / pow(k, 4.0));
} else if (t <= 1.3e-90) {
tmp = ((t / k) * (2.0 / (k / t))) / (t_1 * ((pow(t, 2.0) / l) * (t / l)));
} else if (t <= 2e+95) {
tmp = (2.0 / ((k / t) / (t / k))) / (((t_1 * pow(t, 3.0)) / l) / l);
} else {
tmp = 2.0 * (pow(l, 2.0) / (t * pow(k, 4.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) :: t_1
real(8) :: tmp
t_1 = sin(k) * tan(k)
if (t <= 1.35d-167) then
tmp = 2.0d0 * (((l ** 2.0d0) / t) / (k ** 4.0d0))
else if (t <= 1.3d-90) then
tmp = ((t / k) * (2.0d0 / (k / t))) / (t_1 * (((t ** 2.0d0) / l) * (t / l)))
else if (t <= 2d+95) then
tmp = (2.0d0 / ((k / t) / (t / k))) / (((t_1 * (t ** 3.0d0)) / l) / l)
else
tmp = 2.0d0 * ((l ** 2.0d0) / (t * (k ** 4.0d0)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.sin(k) * Math.tan(k);
double tmp;
if (t <= 1.35e-167) {
tmp = 2.0 * ((Math.pow(l, 2.0) / t) / Math.pow(k, 4.0));
} else if (t <= 1.3e-90) {
tmp = ((t / k) * (2.0 / (k / t))) / (t_1 * ((Math.pow(t, 2.0) / l) * (t / l)));
} else if (t <= 2e+95) {
tmp = (2.0 / ((k / t) / (t / k))) / (((t_1 * Math.pow(t, 3.0)) / l) / l);
} else {
tmp = 2.0 * (Math.pow(l, 2.0) / (t * Math.pow(k, 4.0)));
}
return tmp;
}
def code(t, l, k): t_1 = math.sin(k) * math.tan(k) tmp = 0 if t <= 1.35e-167: tmp = 2.0 * ((math.pow(l, 2.0) / t) / math.pow(k, 4.0)) elif t <= 1.3e-90: tmp = ((t / k) * (2.0 / (k / t))) / (t_1 * ((math.pow(t, 2.0) / l) * (t / l))) elif t <= 2e+95: tmp = (2.0 / ((k / t) / (t / k))) / (((t_1 * math.pow(t, 3.0)) / l) / l) else: tmp = 2.0 * (math.pow(l, 2.0) / (t * math.pow(k, 4.0))) return tmp
function code(t, l, k) t_1 = Float64(sin(k) * tan(k)) tmp = 0.0 if (t <= 1.35e-167) tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) / t) / (k ^ 4.0))); elseif (t <= 1.3e-90) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 / Float64(k / t))) / Float64(t_1 * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))); elseif (t <= 2e+95) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(Float64(Float64(t_1 * (t ^ 3.0)) / l) / l)); else tmp = Float64(2.0 * Float64((l ^ 2.0) / Float64(t * (k ^ 4.0)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = sin(k) * tan(k); tmp = 0.0; if (t <= 1.35e-167) tmp = 2.0 * (((l ^ 2.0) / t) / (k ^ 4.0)); elseif (t <= 1.3e-90) tmp = ((t / k) * (2.0 / (k / t))) / (t_1 * (((t ^ 2.0) / l) * (t / l))); elseif (t <= 2e+95) tmp = (2.0 / ((k / t) / (t / k))) / (((t_1 * (t ^ 3.0)) / l) / l); else tmp = 2.0 * ((l ^ 2.0) / (t * (k ^ 4.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, 1.35e-167], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / t), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.3e-90], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 / N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2e+95], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(t$95$1 * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Power[l, 2.0], $MachinePrecision] / N[(t * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin k \cdot \tan k\\
\mathbf{if}\;t \leq 1.35 \cdot 10^{-167}:\\
\;\;\;\;2 \cdot \frac{\frac{{\ell}^{2}}{t}}{{k}^{4}}\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{-90}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \frac{2}{\frac{k}{t}}}{t\_1 \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)}\\
\mathbf{elif}\;t \leq 2 \cdot 10^{+95}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\frac{\frac{t\_1 \cdot {t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2}}{t \cdot {k}^{4}}\\
\end{array}
\end{array}
if t < 1.35e-167Initial program 32.6%
Simplified39.1%
Taylor expanded in k around 0 64.5%
*-commutative64.5%
associate-/r*63.0%
Simplified63.0%
if 1.35e-167 < t < 1.3e-90Initial program 29.0%
*-commutative29.0%
associate-/r*29.0%
Simplified29.0%
+-rgt-identity29.0%
unpow229.0%
clear-num29.0%
un-div-inv29.0%
Applied egg-rr29.0%
associate-/r/29.0%
Applied egg-rr29.0%
unpow329.0%
times-frac64.0%
pow264.0%
Applied egg-rr64.0%
if 1.3e-90 < t < 2.00000000000000004e95Initial program 70.9%
*-commutative70.9%
associate-/r*70.9%
Simplified70.9%
+-rgt-identity70.9%
unpow270.9%
clear-num70.9%
un-div-inv70.9%
Applied egg-rr70.9%
associate-*l/73.6%
associate-/r*84.3%
Applied egg-rr84.3%
if 2.00000000000000004e95 < t Initial program 10.8%
Simplified29.7%
Taylor expanded in k around 0 56.5%
Final simplification65.2%
(FPCore (t l k)
:precision binary64
(if (<= t 3.05e-111)
(/ (* (pow l 2.0) (/ 2.0 t)) (pow k 4.0))
(if (<= t 1.95e+95)
(/
(* (/ t k) (/ 2.0 (/ k t)))
(/ (* (* (sin k) (tan k)) (/ (pow t 3.0) l)) l))
(* 2.0 (/ (pow l 2.0) (* t (pow k 4.0)))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 3.05e-111) {
tmp = (pow(l, 2.0) * (2.0 / t)) / pow(k, 4.0);
} else if (t <= 1.95e+95) {
tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * (pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 * (pow(l, 2.0) / (t * pow(k, 4.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 <= 3.05d-111) then
tmp = ((l ** 2.0d0) * (2.0d0 / t)) / (k ** 4.0d0)
else if (t <= 1.95d+95) then
tmp = ((t / k) * (2.0d0 / (k / t))) / (((sin(k) * tan(k)) * ((t ** 3.0d0) / l)) / l)
else
tmp = 2.0d0 * ((l ** 2.0d0) / (t * (k ** 4.0d0)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 3.05e-111) {
tmp = (Math.pow(l, 2.0) * (2.0 / t)) / Math.pow(k, 4.0);
} else if (t <= 1.95e+95) {
tmp = ((t / k) * (2.0 / (k / t))) / (((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / l)) / l);
} else {
tmp = 2.0 * (Math.pow(l, 2.0) / (t * Math.pow(k, 4.0)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 3.05e-111: tmp = (math.pow(l, 2.0) * (2.0 / t)) / math.pow(k, 4.0) elif t <= 1.95e+95: tmp = ((t / k) * (2.0 / (k / t))) / (((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / l)) / l) else: tmp = 2.0 * (math.pow(l, 2.0) / (t * math.pow(k, 4.0))) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 3.05e-111) tmp = Float64(Float64((l ^ 2.0) * Float64(2.0 / t)) / (k ^ 4.0)); elseif (t <= 1.95e+95) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 / Float64(k / t))) / Float64(Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / l)) / l)); else tmp = Float64(2.0 * Float64((l ^ 2.0) / Float64(t * (k ^ 4.0)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 3.05e-111) tmp = ((l ^ 2.0) * (2.0 / t)) / (k ^ 4.0); elseif (t <= 1.95e+95) tmp = ((t / k) * (2.0 / (k / t))) / (((sin(k) * tan(k)) * ((t ^ 3.0) / l)) / l); else tmp = 2.0 * ((l ^ 2.0) / (t * (k ^ 4.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 3.05e-111], N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.95e+95], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 / N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Power[l, 2.0], $MachinePrecision] / N[(t * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.05 \cdot 10^{-111}:\\
\;\;\;\;\frac{{\ell}^{2} \cdot \frac{2}{t}}{{k}^{4}}\\
\mathbf{elif}\;t \leq 1.95 \cdot 10^{+95}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \frac{2}{\frac{k}{t}}}{\frac{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2}}{t \cdot {k}^{4}}\\
\end{array}
\end{array}
if t < 3.0500000000000001e-111Initial program 31.5%
Simplified37.8%
Taylor expanded in k around 0 64.1%
*-commutative64.1%
associate-/r*64.0%
Simplified64.0%
associate-*l/62.8%
pow262.8%
Applied egg-rr62.8%
if 3.0500000000000001e-111 < t < 1.9499999999999999e95Initial program 67.2%
*-commutative67.2%
associate-/r*67.2%
Simplified67.2%
+-rgt-identity67.2%
unpow267.2%
clear-num67.2%
un-div-inv67.2%
Applied egg-rr67.2%
associate-/r/67.2%
Applied egg-rr67.2%
associate-/r*76.0%
associate-*l/80.5%
Applied egg-rr80.5%
if 1.9499999999999999e95 < t Initial program 10.8%
Simplified29.7%
Taylor expanded in k around 0 56.5%
Final simplification65.0%
(FPCore (t l k) :precision binary64 (/ (* (pow l 2.0) (* 2.0 (pow k -4.0))) t))
double code(double t, double l, double k) {
return (pow(l, 2.0) * (2.0 * pow(k, -4.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 = ((l ** 2.0d0) * (2.0d0 * (k ** (-4.0d0)))) / t
end function
public static double code(double t, double l, double k) {
return (Math.pow(l, 2.0) * (2.0 * Math.pow(k, -4.0))) / t;
}
def code(t, l, k): return (math.pow(l, 2.0) * (2.0 * math.pow(k, -4.0))) / t
function code(t, l, k) return Float64(Float64((l ^ 2.0) * Float64(2.0 * (k ^ -4.0))) / t) end
function tmp = code(t, l, k) tmp = ((l ^ 2.0) * (2.0 * (k ^ -4.0))) / t; end
code[t_, l_, k_] := N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[(2.0 * N[Power[k, -4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]
\begin{array}{l}
\\
\frac{{\ell}^{2} \cdot \left(2 \cdot {k}^{-4}\right)}{t}
\end{array}
Initial program 34.8%
Simplified42.2%
Taylor expanded in k around 0 62.9%
*-commutative62.9%
associate-/r*62.9%
Simplified62.9%
div-inv62.6%
pow-flip62.6%
metadata-eval62.6%
Applied egg-rr62.6%
associate-*l/62.6%
Simplified62.6%
associate-*l/63.5%
pow263.5%
Applied egg-rr63.5%
Final simplification63.5%
(FPCore (t l k) :precision binary64 (* (* l l) (/ 2.0 (* t (pow k 4.0)))))
double code(double t, double l, double k) {
return (l * l) * (2.0 / (t * 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 = (l * l) * (2.0d0 / (t * (k ** 4.0d0)))
end function
public static double code(double t, double l, double k) {
return (l * l) * (2.0 / (t * Math.pow(k, 4.0)));
}
def code(t, l, k): return (l * l) * (2.0 / (t * math.pow(k, 4.0)))
function code(t, l, k) return Float64(Float64(l * l) * Float64(2.0 / Float64(t * (k ^ 4.0)))) end
function tmp = code(t, l, k) tmp = (l * l) * (2.0 / (t * (k ^ 4.0))); end
code[t_, l_, k_] := N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(t * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\ell \cdot \ell\right) \cdot \frac{2}{t \cdot {k}^{4}}
\end{array}
Initial program 34.8%
Simplified42.2%
Taylor expanded in k around 0 62.9%
Final simplification62.9%
herbie shell --seed 2024181
(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))))