
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 22 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
(FPCore (t l k)
:precision binary64
(if (or (<= t -1e-8) (not (<= t 9.5e-87)))
(/
(pow
(* (/ (cbrt (/ 2.0 (tan k))) t) (* (cbrt l) (/ (cbrt l) (cbrt (sin k)))))
3.0)
(+ 2.0 (pow (/ k t) 2.0)))
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -1e-8) || !(t <= 9.5e-87)) {
tmp = pow(((cbrt((2.0 / tan(k))) / t) * (cbrt(l) * (cbrt(l) / cbrt(sin(k))))), 3.0) / (2.0 + pow((k / t), 2.0));
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -1e-8) || !(t <= 9.5e-87)) {
tmp = Math.pow(((Math.cbrt((2.0 / Math.tan(k))) / t) * (Math.cbrt(l) * (Math.cbrt(l) / Math.cbrt(Math.sin(k))))), 3.0) / (2.0 + Math.pow((k / t), 2.0));
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -1e-8) || !(t <= 9.5e-87)) tmp = Float64((Float64(Float64(cbrt(Float64(2.0 / tan(k))) / t) * Float64(cbrt(l) * Float64(cbrt(l) / cbrt(sin(k))))) ^ 3.0) / Float64(2.0 + (Float64(k / t) ^ 2.0))); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -1e-8], N[Not[LessEqual[t, 9.5e-87]], $MachinePrecision]], N[(N[Power[N[(N[(N[Power[N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t), $MachinePrecision] * N[(N[Power[l, 1/3], $MachinePrecision] * N[(N[Power[l, 1/3], $MachinePrecision] / N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1 \cdot 10^{-8} \lor \neg \left(t \leq 9.5 \cdot 10^{-87}\right):\\
\;\;\;\;\frac{{\left(\frac{\sqrt[3]{\frac{2}{\tan k}}}{t} \cdot \left(\sqrt[3]{\ell} \cdot \frac{\sqrt[3]{\ell}}{\sqrt[3]{\sin k}}\right)\right)}^{3}}{2 + {\left(\frac{k}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\right)\\
\end{array}
\end{array}
if t < -1e-8 or 9.5e-87 < t Initial program 64.4%
associate-/r*64.4%
associate-*l*56.6%
sqr-neg56.6%
associate-*l*64.4%
*-commutative64.4%
sqr-neg64.4%
associate-/r*64.4%
Simplified64.9%
associate-/l/64.9%
associate-/r/64.4%
add-cube-cbrt64.3%
Applied egg-rr77.3%
pow-plus77.2%
metadata-eval77.2%
associate-/r/77.3%
associate-/r/77.3%
Simplified77.3%
cbrt-prod88.5%
Applied egg-rr88.5%
cbrt-div96.8%
Applied egg-rr96.8%
if -1e-8 < t < 9.5e-87Initial program 45.3%
associate-/r*45.3%
associate-*l*45.3%
sqr-neg45.3%
associate-*l*45.3%
*-commutative45.3%
sqr-neg45.3%
associate-/r*45.3%
Simplified45.3%
associate-/l/45.3%
associate-/r/45.3%
add-cube-cbrt45.3%
Applied egg-rr63.2%
pow-plus63.2%
metadata-eval63.2%
associate-/r/63.2%
associate-/r/63.2%
Simplified63.2%
cbrt-prod63.0%
Applied egg-rr63.0%
cbrt-div63.0%
Applied egg-rr63.0%
Taylor expanded in k around inf 76.2%
*-commutative76.2%
times-frac75.3%
unpow275.3%
unpow275.3%
times-frac84.6%
associate-*r*87.1%
unpow287.1%
associate-*l/87.2%
unpow287.2%
Simplified87.2%
Final simplification92.5%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))
(+ (+ t_1 1.0) 1.0)))
1e+226)
(/
(* (* l l) (/ 2.0 (pow (* (* t (cbrt (sin k))) (cbrt (tan k))) 3.0)))
(+ 2.0 t_1))
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = ((l * l) * (2.0 / pow(((t * cbrt(sin(k))) * cbrt(tan(k))), 3.0))) / (2.0 + t_1);
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = ((l * l) * (2.0 / Math.pow(((t * Math.cbrt(Math.sin(k))) * Math.cbrt(Math.tan(k))), 3.0))) / (2.0 + t_1);
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))) * Float64(Float64(t_1 + 1.0) + 1.0))) <= 1e+226) tmp = Float64(Float64(Float64(l * l) * Float64(2.0 / (Float64(Float64(t * cbrt(sin(k))) * cbrt(tan(k))) ^ 3.0))) / Float64(2.0 + t_1)); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$1 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+226], N[(N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[(t * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision] * N[Power[N[Tan[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right) \cdot \left(\left(t_1 + 1\right) + 1\right)} \leq 10^{+226}:\\
\;\;\;\;\frac{\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left(\left(t \cdot \sqrt[3]{\sin k}\right) \cdot \sqrt[3]{\tan k}\right)}^{3}}}{2 + t_1}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\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))) < 9.99999999999999961e225Initial program 79.4%
associate-/r*79.4%
associate-*l*71.9%
sqr-neg71.9%
associate-*l*79.4%
*-commutative79.4%
sqr-neg79.4%
associate-*l/80.0%
associate-*r/78.7%
associate-/r/79.1%
Simplified79.1%
add-cube-cbrt78.9%
pow378.9%
*-commutative78.9%
cbrt-prod78.9%
cbrt-prod78.7%
rem-cbrt-cube88.0%
Applied egg-rr88.0%
if 9.99999999999999961e225 < (/.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 23.4%
associate-/r*23.4%
associate-*l*23.4%
sqr-neg23.4%
associate-*l*23.4%
*-commutative23.4%
sqr-neg23.4%
associate-/r*23.4%
Simplified23.4%
associate-/l/23.4%
associate-/r/23.4%
add-cube-cbrt23.4%
Applied egg-rr46.6%
pow-plus46.6%
metadata-eval46.6%
associate-/r/46.6%
associate-/r/46.6%
Simplified46.6%
cbrt-prod57.2%
Applied egg-rr57.2%
cbrt-div62.3%
Applied egg-rr62.3%
Taylor expanded in k around inf 60.1%
*-commutative60.1%
times-frac59.2%
unpow259.2%
unpow259.2%
times-frac72.0%
associate-*r*74.8%
unpow274.8%
associate-*l/74.9%
unpow274.9%
Simplified74.9%
Final simplification82.5%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))
(+ (+ t_1 1.0) 1.0)))
1e+226)
(/
(pow (* (/ (cbrt (/ 2.0 (tan k))) t) (cbrt (* l (/ l (sin k))))) 3.0)
(+ 2.0 t_1))
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = pow(((cbrt((2.0 / tan(k))) / t) * cbrt((l * (l / sin(k))))), 3.0) / (2.0 + t_1);
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = Math.pow(((Math.cbrt((2.0 / Math.tan(k))) / t) * Math.cbrt((l * (l / Math.sin(k))))), 3.0) / (2.0 + t_1);
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))) * Float64(Float64(t_1 + 1.0) + 1.0))) <= 1e+226) tmp = Float64((Float64(Float64(cbrt(Float64(2.0 / tan(k))) / t) * cbrt(Float64(l * Float64(l / sin(k))))) ^ 3.0) / Float64(2.0 + t_1)); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$1 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+226], N[(N[Power[N[(N[(N[Power[N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t), $MachinePrecision] * N[Power[N[(l * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right) \cdot \left(\left(t_1 + 1\right) + 1\right)} \leq 10^{+226}:\\
\;\;\;\;\frac{{\left(\frac{\sqrt[3]{\frac{2}{\tan k}}}{t} \cdot \sqrt[3]{\ell \cdot \frac{\ell}{\sin k}}\right)}^{3}}{2 + t_1}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\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))) < 9.99999999999999961e225Initial program 79.4%
associate-/r*79.4%
associate-*l*71.9%
sqr-neg71.9%
associate-*l*79.4%
*-commutative79.4%
sqr-neg79.4%
associate-/r*79.4%
Simplified79.9%
associate-/l/79.9%
associate-/r/79.4%
add-cube-cbrt79.3%
Applied egg-rr88.6%
pow-plus88.6%
metadata-eval88.6%
associate-/r/88.6%
associate-/r/88.7%
Simplified88.7%
if 9.99999999999999961e225 < (/.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 23.4%
associate-/r*23.4%
associate-*l*23.4%
sqr-neg23.4%
associate-*l*23.4%
*-commutative23.4%
sqr-neg23.4%
associate-/r*23.4%
Simplified23.4%
associate-/l/23.4%
associate-/r/23.4%
add-cube-cbrt23.4%
Applied egg-rr46.6%
pow-plus46.6%
metadata-eval46.6%
associate-/r/46.6%
associate-/r/46.6%
Simplified46.6%
cbrt-prod57.2%
Applied egg-rr57.2%
cbrt-div62.3%
Applied egg-rr62.3%
Taylor expanded in k around inf 60.1%
*-commutative60.1%
times-frac59.2%
unpow259.2%
unpow259.2%
times-frac72.0%
associate-*r*74.8%
unpow274.8%
associate-*l/74.9%
unpow274.9%
Simplified74.9%
Final simplification82.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))
(+ (+ t_1 1.0) 1.0)))
1e+226)
(*
(pow (/ (cbrt (/ 2.0 (tan k))) t) 3.0)
(/ (* l (/ l (sin k))) (+ 2.0 t_1)))
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = pow((cbrt((2.0 / tan(k))) / t), 3.0) * ((l * (l / sin(k))) / (2.0 + t_1));
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = Math.pow((Math.cbrt((2.0 / Math.tan(k))) / t), 3.0) * ((l * (l / Math.sin(k))) / (2.0 + t_1));
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))) * Float64(Float64(t_1 + 1.0) + 1.0))) <= 1e+226) tmp = Float64((Float64(cbrt(Float64(2.0 / tan(k))) / t) ^ 3.0) * Float64(Float64(l * Float64(l / sin(k))) / Float64(2.0 + t_1))); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$1 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+226], N[(N[Power[N[(N[Power[N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[(l * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right) \cdot \left(\left(t_1 + 1\right) + 1\right)} \leq 10^{+226}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\frac{2}{\tan k}}}{t}\right)}^{3} \cdot \frac{\ell \cdot \frac{\ell}{\sin k}}{2 + t_1}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\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))) < 9.99999999999999961e225Initial program 79.4%
associate-/r*79.4%
associate-*l*71.9%
sqr-neg71.9%
associate-*l*79.4%
*-commutative79.4%
sqr-neg79.4%
associate-/r*79.4%
Simplified79.9%
associate-/l/79.9%
associate-/r/79.4%
add-cube-cbrt79.3%
Applied egg-rr88.6%
pow-plus88.6%
metadata-eval88.6%
associate-/r/88.6%
associate-/r/88.7%
Simplified88.7%
div-inv88.7%
*-commutative88.7%
associate-*l/86.3%
Applied egg-rr86.3%
associate-*r/86.3%
*-rgt-identity86.3%
cube-prod84.3%
unpow284.3%
rem-cube-cbrt84.3%
associate-/l*83.7%
unpow283.7%
associate-/l*85.5%
associate-/r/85.5%
Simplified85.5%
*-un-lft-identity85.5%
associate-/r/85.3%
*-commutative85.3%
Applied egg-rr85.3%
*-lft-identity85.3%
Simplified85.3%
if 9.99999999999999961e225 < (/.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 23.4%
associate-/r*23.4%
associate-*l*23.4%
sqr-neg23.4%
associate-*l*23.4%
*-commutative23.4%
sqr-neg23.4%
associate-/r*23.4%
Simplified23.4%
associate-/l/23.4%
associate-/r/23.4%
add-cube-cbrt23.4%
Applied egg-rr46.6%
pow-plus46.6%
metadata-eval46.6%
associate-/r/46.6%
associate-/r/46.6%
Simplified46.6%
cbrt-prod57.2%
Applied egg-rr57.2%
cbrt-div62.3%
Applied egg-rr62.3%
Taylor expanded in k around inf 60.1%
*-commutative60.1%
times-frac59.2%
unpow259.2%
unpow259.2%
times-frac72.0%
associate-*r*74.8%
unpow274.8%
associate-*l/74.9%
unpow274.9%
Simplified74.9%
Final simplification80.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))
(+ (+ t_1 1.0) 1.0)))
1e+226)
(/
(* l (/ l (sin k)))
(/ (+ 2.0 t_1) (pow (/ (cbrt (/ 2.0 (tan k))) t) 3.0)))
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = (l * (l / sin(k))) / ((2.0 + t_1) / pow((cbrt((2.0 / tan(k))) / t), 3.0));
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = (l * (l / Math.sin(k))) / ((2.0 + t_1) / Math.pow((Math.cbrt((2.0 / Math.tan(k))) / t), 3.0));
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))) * Float64(Float64(t_1 + 1.0) + 1.0))) <= 1e+226) tmp = Float64(Float64(l * Float64(l / sin(k))) / Float64(Float64(2.0 + t_1) / (Float64(cbrt(Float64(2.0 / tan(k))) / t) ^ 3.0))); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$1 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+226], N[(N[(l * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(2.0 + t$95$1), $MachinePrecision] / N[Power[N[(N[Power[N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right) \cdot \left(\left(t_1 + 1\right) + 1\right)} \leq 10^{+226}:\\
\;\;\;\;\frac{\ell \cdot \frac{\ell}{\sin k}}{\frac{2 + t_1}{{\left(\frac{\sqrt[3]{\frac{2}{\tan k}}}{t}\right)}^{3}}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\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))) < 9.99999999999999961e225Initial program 79.4%
associate-/r*79.4%
associate-*l*71.9%
sqr-neg71.9%
associate-*l*79.4%
*-commutative79.4%
sqr-neg79.4%
associate-/r*79.4%
Simplified79.9%
associate-/l/79.9%
associate-/r/79.4%
add-cube-cbrt79.3%
Applied egg-rr88.6%
pow-plus88.6%
metadata-eval88.6%
associate-/r/88.6%
associate-/r/88.7%
Simplified88.7%
div-inv88.7%
*-commutative88.7%
associate-*l/86.3%
Applied egg-rr86.3%
associate-*r/86.3%
*-rgt-identity86.3%
cube-prod84.3%
unpow284.3%
rem-cube-cbrt84.3%
associate-/l*83.7%
unpow283.7%
associate-/l*85.5%
associate-/r/85.5%
Simplified85.5%
if 9.99999999999999961e225 < (/.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 23.4%
associate-/r*23.4%
associate-*l*23.4%
sqr-neg23.4%
associate-*l*23.4%
*-commutative23.4%
sqr-neg23.4%
associate-/r*23.4%
Simplified23.4%
associate-/l/23.4%
associate-/r/23.4%
add-cube-cbrt23.4%
Applied egg-rr46.6%
pow-plus46.6%
metadata-eval46.6%
associate-/r/46.6%
associate-/r/46.6%
Simplified46.6%
cbrt-prod57.2%
Applied egg-rr57.2%
cbrt-div62.3%
Applied egg-rr62.3%
Taylor expanded in k around inf 60.1%
*-commutative60.1%
times-frac59.2%
unpow259.2%
unpow259.2%
times-frac72.0%
associate-*r*74.8%
unpow274.8%
associate-*l/74.9%
unpow274.9%
Simplified74.9%
Final simplification81.1%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))
(+ (+ t_1 1.0) 1.0)))
1e+226)
(* (/ l (sin k)) (* l (/ (/ (/ 2.0 (tan k)) (pow t 3.0)) (+ 2.0 t_1))))
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = (l / sin(k)) * (l * (((2.0 / tan(k)) / pow(t, 3.0)) / (2.0 + t_1)));
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / 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) :: t_1
real(8) :: tmp
t_1 = (k / t) ** 2.0d0
if ((2.0d0 / ((tan(k) * (sin(k) * ((t ** 3.0d0) / (l * l)))) * ((t_1 + 1.0d0) + 1.0d0))) <= 1d+226) then
tmp = (l / sin(k)) * (l * (((2.0d0 / tan(k)) / (t ** 3.0d0)) / (2.0d0 + t_1)))
else
tmp = 2.0d0 * (((cos(k) * (l / t)) / (k * k)) * (l / (sin(k) ** 2.0d0)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) {
tmp = (l / Math.sin(k)) * (l * (((2.0 / Math.tan(k)) / Math.pow(t, 3.0)) / (2.0 + t_1)));
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow((k / t), 2.0) tmp = 0 if (2.0 / ((math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226: tmp = (l / math.sin(k)) * (l * (((2.0 / math.tan(k)) / math.pow(t, 3.0)) / (2.0 + t_1))) else: tmp = 2.0 * (((math.cos(k) * (l / t)) / (k * k)) * (l / math.pow(math.sin(k), 2.0))) return tmp
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))) * Float64(Float64(t_1 + 1.0) + 1.0))) <= 1e+226) tmp = Float64(Float64(l / sin(k)) * Float64(l * Float64(Float64(Float64(2.0 / tan(k)) / (t ^ 3.0)) / Float64(2.0 + t_1)))); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (k / t) ^ 2.0; tmp = 0.0; if ((2.0 / ((tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))) * ((t_1 + 1.0) + 1.0))) <= 1e+226) tmp = (l / sin(k)) * (l * (((2.0 / tan(k)) / (t ^ 3.0)) / (2.0 + t_1))); else tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / (sin(k) ^ 2.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$1 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+226], N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[(l * N[(N[(N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right) \cdot \left(\left(t_1 + 1\right) + 1\right)} \leq 10^{+226}:\\
\;\;\;\;\frac{\ell}{\sin k} \cdot \left(\ell \cdot \frac{\frac{\frac{2}{\tan k}}{{t}^{3}}}{2 + t_1}\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\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))) < 9.99999999999999961e225Initial program 79.4%
associate-/r*79.4%
associate-*l*71.9%
sqr-neg71.9%
associate-*l*79.4%
*-commutative79.4%
sqr-neg79.4%
associate-/r*79.4%
Simplified79.9%
associate-/l/79.9%
associate-/r/79.4%
add-cube-cbrt79.3%
Applied egg-rr88.6%
pow-plus88.6%
metadata-eval88.6%
associate-/r/88.6%
associate-/r/88.7%
Simplified88.7%
div-inv88.7%
*-commutative88.7%
associate-*l/86.3%
Applied egg-rr86.3%
associate-*r/86.3%
*-rgt-identity86.3%
cube-prod84.3%
unpow284.3%
rem-cube-cbrt84.3%
associate-/l*83.7%
unpow283.7%
associate-/l*85.5%
associate-/r/85.5%
Simplified85.5%
div-inv85.5%
*-commutative85.5%
Applied egg-rr85.5%
*-commutative85.5%
associate-*l*86.5%
associate-/r/86.4%
associate-*l/86.5%
metadata-eval86.5%
cube-prod86.5%
*-lft-identity86.5%
cube-div83.8%
rem-cube-cbrt84.0%
Simplified84.0%
if 9.99999999999999961e225 < (/.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 23.4%
associate-/r*23.4%
associate-*l*23.4%
sqr-neg23.4%
associate-*l*23.4%
*-commutative23.4%
sqr-neg23.4%
associate-/r*23.4%
Simplified23.4%
associate-/l/23.4%
associate-/r/23.4%
add-cube-cbrt23.4%
Applied egg-rr46.6%
pow-plus46.6%
metadata-eval46.6%
associate-/r/46.6%
associate-/r/46.6%
Simplified46.6%
cbrt-prod57.2%
Applied egg-rr57.2%
cbrt-div62.3%
Applied egg-rr62.3%
Taylor expanded in k around inf 60.1%
*-commutative60.1%
times-frac59.2%
unpow259.2%
unpow259.2%
times-frac72.0%
associate-*r*74.8%
unpow274.8%
associate-*l/74.9%
unpow274.9%
Simplified74.9%
Final simplification80.2%
(FPCore (t l k)
:precision binary64
(if (or (<= t -3.3e-7) (not (<= t 5.8e-87)))
(/
(pow
(* (cbrt l) (* (/ (cbrt (/ 2.0 (tan k))) t) (cbrt (/ l (sin k)))))
3.0)
(+ 2.0 (pow (/ k t) 2.0)))
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -3.3e-7) || !(t <= 5.8e-87)) {
tmp = pow((cbrt(l) * ((cbrt((2.0 / tan(k))) / t) * cbrt((l / sin(k))))), 3.0) / (2.0 + pow((k / t), 2.0));
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -3.3e-7) || !(t <= 5.8e-87)) {
tmp = Math.pow((Math.cbrt(l) * ((Math.cbrt((2.0 / Math.tan(k))) / t) * Math.cbrt((l / Math.sin(k))))), 3.0) / (2.0 + Math.pow((k / t), 2.0));
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -3.3e-7) || !(t <= 5.8e-87)) tmp = Float64((Float64(cbrt(l) * Float64(Float64(cbrt(Float64(2.0 / tan(k))) / t) * cbrt(Float64(l / sin(k))))) ^ 3.0) / Float64(2.0 + (Float64(k / t) ^ 2.0))); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -3.3e-7], N[Not[LessEqual[t, 5.8e-87]], $MachinePrecision]], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] * N[(N[(N[Power[N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t), $MachinePrecision] * N[Power[N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.3 \cdot 10^{-7} \lor \neg \left(t \leq 5.8 \cdot 10^{-87}\right):\\
\;\;\;\;\frac{{\left(\sqrt[3]{\ell} \cdot \left(\frac{\sqrt[3]{\frac{2}{\tan k}}}{t} \cdot \sqrt[3]{\frac{\ell}{\sin k}}\right)\right)}^{3}}{2 + {\left(\frac{k}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\right)\\
\end{array}
\end{array}
if t < -3.3000000000000002e-7 or 5.7999999999999998e-87 < t Initial program 64.4%
associate-/r*64.4%
associate-*l*56.6%
sqr-neg56.6%
associate-*l*64.4%
*-commutative64.4%
sqr-neg64.4%
associate-/r*64.4%
Simplified64.9%
associate-/l/64.9%
associate-/r/64.4%
add-cube-cbrt64.3%
Applied egg-rr77.3%
pow-plus77.2%
metadata-eval77.2%
associate-/r/77.3%
associate-/r/77.3%
Simplified77.3%
cbrt-prod88.5%
Applied egg-rr88.5%
cbrt-div96.8%
Applied egg-rr96.8%
associate-*l/95.5%
*-commutative95.5%
cbrt-undiv88.5%
Applied egg-rr88.5%
associate-*l/88.5%
*-commutative88.5%
associate-*l*88.5%
Simplified88.5%
if -3.3000000000000002e-7 < t < 5.7999999999999998e-87Initial program 45.3%
associate-/r*45.3%
associate-*l*45.3%
sqr-neg45.3%
associate-*l*45.3%
*-commutative45.3%
sqr-neg45.3%
associate-/r*45.3%
Simplified45.3%
associate-/l/45.3%
associate-/r/45.3%
add-cube-cbrt45.3%
Applied egg-rr63.2%
pow-plus63.2%
metadata-eval63.2%
associate-/r/63.2%
associate-/r/63.2%
Simplified63.2%
cbrt-prod63.0%
Applied egg-rr63.0%
cbrt-div63.0%
Applied egg-rr63.0%
Taylor expanded in k around inf 76.2%
*-commutative76.2%
times-frac75.3%
unpow275.3%
unpow275.3%
times-frac84.6%
associate-*r*87.1%
unpow287.1%
associate-*l/87.2%
unpow287.2%
Simplified87.2%
Final simplification87.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (cbrt (/ l (sin k))))
(t_2 (+ 2.0 (pow (/ k t) 2.0)))
(t_3 (/ (cbrt (/ 2.0 (tan k))) t)))
(if (<= t -2.2e-7)
(/ (pow (* (cbrt l) (* t_3 t_1)) 3.0) t_2)
(if (<= t 2.35e-89)
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0))))
(/ (pow (* t_3 (* (cbrt l) t_1)) 3.0) t_2)))))
double code(double t, double l, double k) {
double t_1 = cbrt((l / sin(k)));
double t_2 = 2.0 + pow((k / t), 2.0);
double t_3 = cbrt((2.0 / tan(k))) / t;
double tmp;
if (t <= -2.2e-7) {
tmp = pow((cbrt(l) * (t_3 * t_1)), 3.0) / t_2;
} else if (t <= 2.35e-89) {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
} else {
tmp = pow((t_3 * (cbrt(l) * t_1)), 3.0) / t_2;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt((l / Math.sin(k)));
double t_2 = 2.0 + Math.pow((k / t), 2.0);
double t_3 = Math.cbrt((2.0 / Math.tan(k))) / t;
double tmp;
if (t <= -2.2e-7) {
tmp = Math.pow((Math.cbrt(l) * (t_3 * t_1)), 3.0) / t_2;
} else if (t <= 2.35e-89) {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
} else {
tmp = Math.pow((t_3 * (Math.cbrt(l) * t_1)), 3.0) / t_2;
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(Float64(l / sin(k))) t_2 = Float64(2.0 + (Float64(k / t) ^ 2.0)) t_3 = Float64(cbrt(Float64(2.0 / tan(k))) / t) tmp = 0.0 if (t <= -2.2e-7) tmp = Float64((Float64(cbrt(l) * Float64(t_3 * t_1)) ^ 3.0) / t_2); elseif (t <= 2.35e-89) tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); else tmp = Float64((Float64(t_3 * Float64(cbrt(l) * t_1)) ^ 3.0) / t_2); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Power[N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t), $MachinePrecision]}, If[LessEqual[t, -2.2e-7], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] * N[(t$95$3 * t$95$1), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[t, 2.35e-89], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(t$95$3 * N[(N[Power[l, 1/3], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\frac{\ell}{\sin k}}\\
t_2 := 2 + {\left(\frac{k}{t}\right)}^{2}\\
t_3 := \frac{\sqrt[3]{\frac{2}{\tan k}}}{t}\\
\mathbf{if}\;t \leq -2.2 \cdot 10^{-7}:\\
\;\;\;\;\frac{{\left(\sqrt[3]{\ell} \cdot \left(t_3 \cdot t_1\right)\right)}^{3}}{t_2}\\
\mathbf{elif}\;t \leq 2.35 \cdot 10^{-89}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(t_3 \cdot \left(\sqrt[3]{\ell} \cdot t_1\right)\right)}^{3}}{t_2}\\
\end{array}
\end{array}
if t < -2.2000000000000001e-7Initial program 62.0%
associate-/r*62.0%
associate-*l*53.5%
sqr-neg53.5%
associate-*l*62.0%
*-commutative62.0%
sqr-neg62.0%
associate-/r*62.0%
Simplified63.5%
associate-/l/63.5%
associate-/r/62.0%
add-cube-cbrt61.9%
Applied egg-rr77.0%
pow-plus77.0%
metadata-eval77.0%
associate-/r/77.0%
associate-/r/77.1%
Simplified77.1%
cbrt-prod88.0%
Applied egg-rr88.0%
cbrt-div97.1%
Applied egg-rr97.1%
associate-*l/95.6%
*-commutative95.6%
cbrt-undiv88.1%
Applied egg-rr88.1%
associate-*l/88.0%
*-commutative88.0%
associate-*l*88.1%
Simplified88.1%
if -2.2000000000000001e-7 < t < 2.34999999999999998e-89Initial program 45.3%
associate-/r*45.3%
associate-*l*45.3%
sqr-neg45.3%
associate-*l*45.3%
*-commutative45.3%
sqr-neg45.3%
associate-/r*45.3%
Simplified45.3%
associate-/l/45.3%
associate-/r/45.3%
add-cube-cbrt45.3%
Applied egg-rr63.2%
pow-plus63.2%
metadata-eval63.2%
associate-/r/63.2%
associate-/r/63.2%
Simplified63.2%
cbrt-prod63.0%
Applied egg-rr63.0%
cbrt-div63.0%
Applied egg-rr63.0%
Taylor expanded in k around inf 76.2%
*-commutative76.2%
times-frac75.3%
unpow275.3%
unpow275.3%
times-frac84.6%
associate-*r*87.1%
unpow287.1%
associate-*l/87.2%
unpow287.2%
Simplified87.2%
if 2.34999999999999998e-89 < t Initial program 66.2%
associate-/r*66.2%
associate-*l*59.0%
sqr-neg59.0%
associate-*l*66.2%
*-commutative66.2%
sqr-neg66.2%
associate-/r*66.2%
Simplified66.0%
associate-/l/66.0%
associate-/r/66.2%
add-cube-cbrt66.1%
Applied egg-rr77.4%
pow-plus77.4%
metadata-eval77.4%
associate-/r/77.5%
associate-/r/77.5%
Simplified77.5%
cbrt-prod88.9%
Applied egg-rr88.9%
Final simplification87.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* (cbrt l) (cbrt (/ l (sin k)))))
(t_2 (+ 2.0 (pow (/ k t) 2.0)))
(t_3 (cbrt (/ 2.0 (tan k)))))
(if (<= t -6.5e-18)
(/ (pow (/ (* t_3 t_1) t) 3.0) t_2)
(if (<= t 2.35e-89)
(* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0))))
(/ (pow (* (/ t_3 t) t_1) 3.0) t_2)))))
double code(double t, double l, double k) {
double t_1 = cbrt(l) * cbrt((l / sin(k)));
double t_2 = 2.0 + pow((k / t), 2.0);
double t_3 = cbrt((2.0 / tan(k)));
double tmp;
if (t <= -6.5e-18) {
tmp = pow(((t_3 * t_1) / t), 3.0) / t_2;
} else if (t <= 2.35e-89) {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / pow(sin(k), 2.0)));
} else {
tmp = pow(((t_3 / t) * t_1), 3.0) / t_2;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt(l) * Math.cbrt((l / Math.sin(k)));
double t_2 = 2.0 + Math.pow((k / t), 2.0);
double t_3 = Math.cbrt((2.0 / Math.tan(k)));
double tmp;
if (t <= -6.5e-18) {
tmp = Math.pow(((t_3 * t_1) / t), 3.0) / t_2;
} else if (t <= 2.35e-89) {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
} else {
tmp = Math.pow(((t_3 / t) * t_1), 3.0) / t_2;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(cbrt(l) * cbrt(Float64(l / sin(k)))) t_2 = Float64(2.0 + (Float64(k / t) ^ 2.0)) t_3 = cbrt(Float64(2.0 / tan(k))) tmp = 0.0 if (t <= -6.5e-18) tmp = Float64((Float64(Float64(t_3 * t_1) / t) ^ 3.0) / t_2); elseif (t <= 2.35e-89) tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); else tmp = Float64((Float64(Float64(t_3 / t) * t_1) ^ 3.0) / t_2); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[Power[l, 1/3], $MachinePrecision] * N[Power[N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Power[N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, If[LessEqual[t, -6.5e-18], N[(N[Power[N[(N[(t$95$3 * t$95$1), $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[t, 2.35e-89], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(N[(t$95$3 / t), $MachinePrecision] * t$95$1), $MachinePrecision], 3.0], $MachinePrecision] / t$95$2), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\ell} \cdot \sqrt[3]{\frac{\ell}{\sin k}}\\
t_2 := 2 + {\left(\frac{k}{t}\right)}^{2}\\
t_3 := \sqrt[3]{\frac{2}{\tan k}}\\
\mathbf{if}\;t \leq -6.5 \cdot 10^{-18}:\\
\;\;\;\;\frac{{\left(\frac{t_3 \cdot t_1}{t}\right)}^{3}}{t_2}\\
\mathbf{elif}\;t \leq 2.35 \cdot 10^{-89}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{t_3}{t} \cdot t_1\right)}^{3}}{t_2}\\
\end{array}
\end{array}
if t < -6.50000000000000008e-18Initial program 61.5%
associate-/r*61.5%
associate-*l*53.4%
sqr-neg53.4%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.4%
Simplified62.9%
associate-/l/62.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.6%
pow-plus75.6%
metadata-eval75.6%
associate-/r/75.6%
associate-/r/75.7%
Simplified75.7%
cbrt-prod85.9%
Applied egg-rr85.9%
cbrt-div94.4%
Applied egg-rr94.4%
associate-*l/93.0%
*-commutative93.0%
cbrt-undiv86.0%
Applied egg-rr86.0%
if -6.50000000000000008e-18 < t < 2.34999999999999998e-89Initial program 45.0%
associate-/r*45.0%
associate-*l*45.0%
sqr-neg45.0%
associate-*l*45.0%
*-commutative45.0%
sqr-neg45.0%
associate-/r*45.0%
Simplified45.0%
associate-/l/45.0%
associate-/r/45.0%
add-cube-cbrt45.0%
Applied egg-rr63.5%
pow-plus63.5%
metadata-eval63.5%
associate-/r/63.5%
associate-/r/63.5%
Simplified63.5%
cbrt-prod63.3%
Applied egg-rr63.3%
cbrt-div63.3%
Applied egg-rr63.3%
Taylor expanded in k around inf 77.9%
*-commutative77.9%
times-frac76.9%
unpow276.9%
unpow276.9%
times-frac86.6%
associate-*r*88.4%
unpow288.4%
associate-*l/88.4%
unpow288.4%
Simplified88.4%
if 2.34999999999999998e-89 < t Initial program 66.2%
associate-/r*66.2%
associate-*l*59.0%
sqr-neg59.0%
associate-*l*66.2%
*-commutative66.2%
sqr-neg66.2%
associate-/r*66.2%
Simplified66.0%
associate-/l/66.0%
associate-/r/66.2%
add-cube-cbrt66.1%
Applied egg-rr77.4%
pow-plus77.4%
metadata-eval77.4%
associate-/r/77.5%
associate-/r/77.5%
Simplified77.5%
cbrt-prod88.9%
Applied egg-rr88.9%
Final simplification87.9%
(FPCore (t l k) :precision binary64 (if (<= k 2e-15) (/ (* l (/ l (sin k))) (* k (pow t 3.0))) (* 2.0 (* (/ (cos k) (* k k)) (* (/ l t) (/ l (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 2e-15) {
tmp = (l * (l / sin(k))) / (k * pow(t, 3.0));
} else {
tmp = 2.0 * ((cos(k) / (k * k)) * ((l / t) * (l / 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 (k <= 2d-15) then
tmp = (l * (l / sin(k))) / (k * (t ** 3.0d0))
else
tmp = 2.0d0 * ((cos(k) / (k * k)) * ((l / t) * (l / (sin(k) ** 2.0d0))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 2e-15) {
tmp = (l * (l / Math.sin(k))) / (k * Math.pow(t, 3.0));
} else {
tmp = 2.0 * ((Math.cos(k) / (k * k)) * ((l / t) * (l / Math.pow(Math.sin(k), 2.0))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 2e-15: tmp = (l * (l / math.sin(k))) / (k * math.pow(t, 3.0)) else: tmp = 2.0 * ((math.cos(k) / (k * k)) * ((l / t) * (l / math.pow(math.sin(k), 2.0)))) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 2e-15) tmp = Float64(Float64(l * Float64(l / sin(k))) / Float64(k * (t ^ 3.0))); else tmp = Float64(2.0 * Float64(Float64(cos(k) / Float64(k * k)) * Float64(Float64(l / t) * Float64(l / (sin(k) ^ 2.0))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 2e-15) tmp = (l * (l / sin(k))) / (k * (t ^ 3.0)); else tmp = 2.0 * ((cos(k) / (k * k)) * ((l / t) * (l / (sin(k) ^ 2.0)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 2e-15], N[(N[(l * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(N[(l / t), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 2 \cdot 10^{-15}:\\
\;\;\;\;\frac{\ell \cdot \frac{\ell}{\sin k}}{k \cdot {t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k}{k \cdot k} \cdot \left(\frac{\ell}{t} \cdot \frac{\ell}{{\sin k}^{2}}\right)\right)\\
\end{array}
\end{array}
if k < 2.0000000000000002e-15Initial program 61.9%
associate-/r*61.9%
associate-*l*55.8%
sqr-neg55.8%
associate-*l*61.9%
*-commutative61.9%
sqr-neg61.9%
associate-/r*61.9%
Simplified62.3%
associate-/l/62.3%
associate-/r/61.9%
add-cube-cbrt61.8%
Applied egg-rr76.4%
pow-plus76.3%
metadata-eval76.3%
associate-/r/76.4%
associate-/r/76.4%
Simplified76.4%
div-inv76.4%
*-commutative76.4%
associate-*l/71.8%
Applied egg-rr71.8%
associate-*r/71.8%
*-rgt-identity71.8%
cube-prod68.1%
unpow268.1%
rem-cube-cbrt68.1%
associate-/l*67.6%
unpow267.6%
associate-/l*71.8%
associate-/r/71.8%
Simplified71.8%
Taylor expanded in k around 0 64.2%
if 2.0000000000000002e-15 < k Initial program 41.2%
associate-/r*41.2%
associate-*l*41.2%
sqr-neg41.2%
associate-*l*41.2%
*-commutative41.2%
sqr-neg41.2%
associate-*l/41.2%
associate-*r/41.2%
associate-/r/41.2%
Simplified41.2%
Taylor expanded in k around inf 78.7%
times-frac78.7%
unpow278.7%
unpow278.7%
*-commutative78.7%
times-frac81.5%
Simplified81.5%
Final simplification69.2%
(FPCore (t l k) :precision binary64 (if (<= k 8.5e-13) (/ (* l (/ l (sin k))) (* k (pow t 3.0))) (* 2.0 (* (/ (* (cos k) (/ l t)) (* k k)) (/ l (pow (sin k) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 8.5e-13) {
tmp = (l * (l / sin(k))) / (k * pow(t, 3.0));
} else {
tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / 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 (k <= 8.5d-13) then
tmp = (l * (l / sin(k))) / (k * (t ** 3.0d0))
else
tmp = 2.0d0 * (((cos(k) * (l / t)) / (k * k)) * (l / (sin(k) ** 2.0d0)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 8.5e-13) {
tmp = (l * (l / Math.sin(k))) / (k * Math.pow(t, 3.0));
} else {
tmp = 2.0 * (((Math.cos(k) * (l / t)) / (k * k)) * (l / Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 8.5e-13: tmp = (l * (l / math.sin(k))) / (k * math.pow(t, 3.0)) else: tmp = 2.0 * (((math.cos(k) * (l / t)) / (k * k)) * (l / math.pow(math.sin(k), 2.0))) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 8.5e-13) tmp = Float64(Float64(l * Float64(l / sin(k))) / Float64(k * (t ^ 3.0))); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) * Float64(l / t)) / Float64(k * k)) * Float64(l / (sin(k) ^ 2.0)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 8.5e-13) tmp = (l * (l / sin(k))) / (k * (t ^ 3.0)); else tmp = 2.0 * (((cos(k) * (l / t)) / (k * k)) * (l / (sin(k) ^ 2.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 8.5e-13], N[(N[(l * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 8.5 \cdot 10^{-13}:\\
\;\;\;\;\frac{\ell \cdot \frac{\ell}{\sin k}}{k \cdot {t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k \cdot \frac{\ell}{t}}{k \cdot k} \cdot \frac{\ell}{{\sin k}^{2}}\right)\\
\end{array}
\end{array}
if k < 8.5000000000000001e-13Initial program 61.9%
associate-/r*61.9%
associate-*l*55.8%
sqr-neg55.8%
associate-*l*61.9%
*-commutative61.9%
sqr-neg61.9%
associate-/r*61.9%
Simplified62.3%
associate-/l/62.3%
associate-/r/61.9%
add-cube-cbrt61.8%
Applied egg-rr76.4%
pow-plus76.3%
metadata-eval76.3%
associate-/r/76.4%
associate-/r/76.4%
Simplified76.4%
div-inv76.4%
*-commutative76.4%
associate-*l/71.8%
Applied egg-rr71.8%
associate-*r/71.8%
*-rgt-identity71.8%
cube-prod68.1%
unpow268.1%
rem-cube-cbrt68.1%
associate-/l*67.6%
unpow267.6%
associate-/l*71.8%
associate-/r/71.8%
Simplified71.8%
Taylor expanded in k around 0 64.2%
if 8.5000000000000001e-13 < k Initial program 41.2%
associate-/r*41.2%
associate-*l*41.2%
sqr-neg41.2%
associate-*l*41.2%
*-commutative41.2%
sqr-neg41.2%
associate-/r*41.2%
Simplified41.2%
associate-/l/41.2%
associate-/r/41.2%
add-cube-cbrt41.2%
Applied egg-rr57.7%
pow-plus57.7%
metadata-eval57.7%
associate-/r/57.7%
associate-/r/57.7%
Simplified57.7%
cbrt-prod65.7%
Applied egg-rr65.7%
cbrt-div65.6%
Applied egg-rr65.6%
Taylor expanded in k around inf 78.7%
*-commutative78.7%
times-frac78.7%
unpow278.7%
unpow278.7%
times-frac81.5%
associate-*r*81.8%
unpow281.8%
associate-*l/81.9%
unpow281.9%
Simplified81.9%
Final simplification69.2%
(FPCore (t l k) :precision binary64 (if (<= k 22500000.0) (/ (* l (/ l (sin k))) (* k (pow t 3.0))) (* 2.0 (/ (cos k) (* (/ 3.0 l) (/ (* t (* k k)) l))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 22500000.0) {
tmp = (l * (l / sin(k))) / (k * pow(t, 3.0));
} else {
tmp = 2.0 * (cos(k) / ((3.0 / l) * ((t * (k * k)) / 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 (k <= 22500000.0d0) then
tmp = (l * (l / sin(k))) / (k * (t ** 3.0d0))
else
tmp = 2.0d0 * (cos(k) / ((3.0d0 / l) * ((t * (k * k)) / l)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 22500000.0) {
tmp = (l * (l / Math.sin(k))) / (k * Math.pow(t, 3.0));
} else {
tmp = 2.0 * (Math.cos(k) / ((3.0 / l) * ((t * (k * k)) / l)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 22500000.0: tmp = (l * (l / math.sin(k))) / (k * math.pow(t, 3.0)) else: tmp = 2.0 * (math.cos(k) / ((3.0 / l) * ((t * (k * k)) / l))) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 22500000.0) tmp = Float64(Float64(l * Float64(l / sin(k))) / Float64(k * (t ^ 3.0))); else tmp = Float64(2.0 * Float64(cos(k) / Float64(Float64(3.0 / l) * Float64(Float64(t * Float64(k * k)) / l)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 22500000.0) tmp = (l * (l / sin(k))) / (k * (t ^ 3.0)); else tmp = 2.0 * (cos(k) / ((3.0 / l) * ((t * (k * k)) / l))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 22500000.0], N[(N[(l * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Cos[k], $MachinePrecision] / N[(N[(3.0 / l), $MachinePrecision] * N[(N[(t * N[(k * k), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 22500000:\\
\;\;\;\;\frac{\ell \cdot \frac{\ell}{\sin k}}{k \cdot {t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\cos k}{\frac{3}{\ell} \cdot \frac{t \cdot \left(k \cdot k\right)}{\ell}}\\
\end{array}
\end{array}
if k < 2.25e7Initial program 61.5%
associate-/r*61.5%
associate-*l*55.6%
sqr-neg55.6%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.5%
Simplified61.9%
associate-/l/61.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.5%
pow-plus75.5%
metadata-eval75.5%
associate-/r/75.5%
associate-/r/75.5%
Simplified75.5%
div-inv75.5%
*-commutative75.5%
associate-*l/71.1%
Applied egg-rr71.1%
associate-*r/71.1%
*-rgt-identity71.1%
cube-prod67.5%
unpow267.5%
rem-cube-cbrt67.5%
associate-/l*67.0%
unpow267.0%
associate-/l*71.1%
associate-/r/71.1%
Simplified71.1%
Taylor expanded in k around 0 64.3%
if 2.25e7 < k Initial program 40.4%
associate-/r*40.4%
associate-*l*40.4%
sqr-neg40.4%
associate-*l*40.4%
*-commutative40.4%
sqr-neg40.4%
associate-*l/40.4%
associate-*r/40.4%
associate-/r/40.4%
Simplified40.4%
Taylor expanded in k around inf 78.2%
times-frac78.3%
unpow278.3%
unpow278.3%
*-commutative78.3%
Simplified78.3%
Taylor expanded in k around 0 69.5%
+-commutative69.5%
fma-def69.5%
unpow269.5%
associate-/l*69.5%
*-commutative69.5%
associate-/r*69.6%
unpow269.6%
associate-/l*72.7%
unpow272.7%
Simplified72.7%
Taylor expanded in l around 0 69.6%
associate-/l*69.6%
unpow269.6%
*-commutative69.6%
unpow269.6%
associate-*l*72.7%
associate-*r/72.7%
metadata-eval72.7%
*-commutative72.7%
associate-/r*72.7%
unpow272.7%
Simplified72.7%
Taylor expanded in k around inf 69.5%
associate-*r/69.5%
unpow269.5%
times-frac74.5%
unpow274.5%
Simplified74.5%
Final simplification67.0%
(FPCore (t l k)
:precision binary64
(if (<= t -4.9e-17)
(/ l (/ (* k (* k (pow t 3.0))) l))
(if (<= t 4.6e-90)
(*
2.0
(/
(cos k)
(*
(/ k l)
(/ k (* l (+ (/ 0.3333333333333333 t) (/ (/ 1.0 t) (* k k))))))))
(/ (* (/ l k) (/ l k)) (pow t 3.0)))))
double code(double t, double l, double k) {
double tmp;
if (t <= -4.9e-17) {
tmp = l / ((k * (k * pow(t, 3.0))) / l);
} else if (t <= 4.6e-90) {
tmp = 2.0 * (cos(k) / ((k / l) * (k / (l * ((0.3333333333333333 / t) + ((1.0 / t) / (k * k)))))));
} else {
tmp = ((l / k) * (l / k)) / pow(t, 3.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 <= (-4.9d-17)) then
tmp = l / ((k * (k * (t ** 3.0d0))) / l)
else if (t <= 4.6d-90) then
tmp = 2.0d0 * (cos(k) / ((k / l) * (k / (l * ((0.3333333333333333d0 / t) + ((1.0d0 / t) / (k * k)))))))
else
tmp = ((l / k) * (l / k)) / (t ** 3.0d0)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= -4.9e-17) {
tmp = l / ((k * (k * Math.pow(t, 3.0))) / l);
} else if (t <= 4.6e-90) {
tmp = 2.0 * (Math.cos(k) / ((k / l) * (k / (l * ((0.3333333333333333 / t) + ((1.0 / t) / (k * k)))))));
} else {
tmp = ((l / k) * (l / k)) / Math.pow(t, 3.0);
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= -4.9e-17: tmp = l / ((k * (k * math.pow(t, 3.0))) / l) elif t <= 4.6e-90: tmp = 2.0 * (math.cos(k) / ((k / l) * (k / (l * ((0.3333333333333333 / t) + ((1.0 / t) / (k * k))))))) else: tmp = ((l / k) * (l / k)) / math.pow(t, 3.0) return tmp
function code(t, l, k) tmp = 0.0 if (t <= -4.9e-17) tmp = Float64(l / Float64(Float64(k * Float64(k * (t ^ 3.0))) / l)); elseif (t <= 4.6e-90) tmp = Float64(2.0 * Float64(cos(k) / Float64(Float64(k / l) * Float64(k / Float64(l * Float64(Float64(0.3333333333333333 / t) + Float64(Float64(1.0 / t) / Float64(k * k)))))))); else tmp = Float64(Float64(Float64(l / k) * Float64(l / k)) / (t ^ 3.0)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= -4.9e-17) tmp = l / ((k * (k * (t ^ 3.0))) / l); elseif (t <= 4.6e-90) tmp = 2.0 * (cos(k) / ((k / l) * (k / (l * ((0.3333333333333333 / t) + ((1.0 / t) / (k * k))))))); else tmp = ((l / k) * (l / k)) / (t ^ 3.0); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, -4.9e-17], N[(l / N[(N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.6e-90], N[(2.0 * N[(N[Cos[k], $MachinePrecision] / N[(N[(k / l), $MachinePrecision] * N[(k / N[(l * N[(N[(0.3333333333333333 / t), $MachinePrecision] + N[(N[(1.0 / t), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.9 \cdot 10^{-17}:\\
\;\;\;\;\frac{\ell}{\frac{k \cdot \left(k \cdot {t}^{3}\right)}{\ell}}\\
\mathbf{elif}\;t \leq 4.6 \cdot 10^{-90}:\\
\;\;\;\;2 \cdot \frac{\cos k}{\frac{k}{\ell} \cdot \frac{k}{\ell \cdot \left(\frac{0.3333333333333333}{t} + \frac{\frac{1}{t}}{k \cdot k}\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\ell}{k} \cdot \frac{\ell}{k}}{{t}^{3}}\\
\end{array}
\end{array}
if t < -4.90000000000000012e-17Initial program 61.5%
associate-/r*61.5%
associate-*l*53.4%
sqr-neg53.4%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.4%
Simplified62.9%
associate-/l/62.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.6%
pow-plus75.6%
metadata-eval75.6%
associate-/r/75.6%
associate-/r/75.7%
Simplified75.7%
cbrt-prod85.9%
Applied egg-rr85.9%
Taylor expanded in k around 0 54.7%
unpow254.7%
associate-/l*58.3%
unpow258.3%
associate-*l*65.2%
Simplified65.2%
if -4.90000000000000012e-17 < t < 4.5999999999999996e-90Initial program 45.0%
associate-/r*45.0%
associate-*l*45.0%
sqr-neg45.0%
associate-*l*45.0%
*-commutative45.0%
sqr-neg45.0%
associate-*l/45.0%
associate-*r/45.0%
associate-/r/45.0%
Simplified45.0%
Taylor expanded in k around inf 77.9%
times-frac76.9%
unpow276.9%
unpow276.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in k around 0 69.3%
+-commutative69.3%
fma-def69.3%
unpow269.3%
associate-/l*69.5%
*-commutative69.5%
associate-/r*71.2%
unpow271.2%
associate-/l*74.8%
unpow274.8%
Simplified74.8%
Taylor expanded in l around 0 69.3%
associate-/l*69.3%
unpow269.3%
*-commutative69.3%
unpow269.3%
associate-*l*75.0%
associate-*r/75.0%
metadata-eval75.0%
*-commutative75.0%
associate-/r*75.0%
unpow275.0%
Simplified75.0%
times-frac76.2%
Applied egg-rr76.2%
if 4.5999999999999996e-90 < t Initial program 66.2%
associate-/r*66.2%
associate-*l*59.0%
sqr-neg59.0%
associate-*l*66.2%
*-commutative66.2%
sqr-neg66.2%
associate-/r*66.2%
Simplified66.0%
associate-/l/66.0%
associate-/r/66.2%
add-cube-cbrt66.1%
Applied egg-rr77.4%
pow-plus77.4%
metadata-eval77.4%
associate-/r/77.5%
associate-/r/77.5%
Simplified77.5%
cbrt-prod88.9%
Applied egg-rr88.9%
cbrt-div96.5%
Applied egg-rr96.5%
Taylor expanded in k around 0 55.5%
associate-/r*56.6%
unpow256.6%
unpow256.6%
times-frac69.1%
Simplified69.1%
Final simplification71.1%
(FPCore (t l k)
:precision binary64
(if (<= t -1.4e-17)
(/ l (/ (* k (* k (pow t 3.0))) l))
(if (<= t 6.5e-87)
(*
2.0
(*
(/ (cos k) t)
(/ (- (/ l (/ (* k k) l)) (* l (* l -0.3333333333333333))) (* k k))))
(/ (* (/ l k) (/ l k)) (pow t 3.0)))))
double code(double t, double l, double k) {
double tmp;
if (t <= -1.4e-17) {
tmp = l / ((k * (k * pow(t, 3.0))) / l);
} else if (t <= 6.5e-87) {
tmp = 2.0 * ((cos(k) / t) * (((l / ((k * k) / l)) - (l * (l * -0.3333333333333333))) / (k * k)));
} else {
tmp = ((l / k) * (l / k)) / pow(t, 3.0);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= (-1.4d-17)) then
tmp = l / ((k * (k * (t ** 3.0d0))) / l)
else if (t <= 6.5d-87) then
tmp = 2.0d0 * ((cos(k) / t) * (((l / ((k * k) / l)) - (l * (l * (-0.3333333333333333d0)))) / (k * k)))
else
tmp = ((l / k) * (l / k)) / (t ** 3.0d0)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= -1.4e-17) {
tmp = l / ((k * (k * Math.pow(t, 3.0))) / l);
} else if (t <= 6.5e-87) {
tmp = 2.0 * ((Math.cos(k) / t) * (((l / ((k * k) / l)) - (l * (l * -0.3333333333333333))) / (k * k)));
} else {
tmp = ((l / k) * (l / k)) / Math.pow(t, 3.0);
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= -1.4e-17: tmp = l / ((k * (k * math.pow(t, 3.0))) / l) elif t <= 6.5e-87: tmp = 2.0 * ((math.cos(k) / t) * (((l / ((k * k) / l)) - (l * (l * -0.3333333333333333))) / (k * k))) else: tmp = ((l / k) * (l / k)) / math.pow(t, 3.0) return tmp
function code(t, l, k) tmp = 0.0 if (t <= -1.4e-17) tmp = Float64(l / Float64(Float64(k * Float64(k * (t ^ 3.0))) / l)); elseif (t <= 6.5e-87) tmp = Float64(2.0 * Float64(Float64(cos(k) / t) * Float64(Float64(Float64(l / Float64(Float64(k * k) / l)) - Float64(l * Float64(l * -0.3333333333333333))) / Float64(k * k)))); else tmp = Float64(Float64(Float64(l / k) * Float64(l / k)) / (t ^ 3.0)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= -1.4e-17) tmp = l / ((k * (k * (t ^ 3.0))) / l); elseif (t <= 6.5e-87) tmp = 2.0 * ((cos(k) / t) * (((l / ((k * k) / l)) - (l * (l * -0.3333333333333333))) / (k * k))); else tmp = ((l / k) * (l / k)) / (t ^ 3.0); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, -1.4e-17], N[(l / N[(N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.5e-87], N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision] * N[(N[(N[(l / N[(N[(k * k), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] - N[(l * N[(l * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.4 \cdot 10^{-17}:\\
\;\;\;\;\frac{\ell}{\frac{k \cdot \left(k \cdot {t}^{3}\right)}{\ell}}\\
\mathbf{elif}\;t \leq 6.5 \cdot 10^{-87}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k}{t} \cdot \frac{\frac{\ell}{\frac{k \cdot k}{\ell}} - \ell \cdot \left(\ell \cdot -0.3333333333333333\right)}{k \cdot k}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\ell}{k} \cdot \frac{\ell}{k}}{{t}^{3}}\\
\end{array}
\end{array}
if t < -1.3999999999999999e-17Initial program 61.5%
associate-/r*61.5%
associate-*l*53.4%
sqr-neg53.4%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.4%
Simplified62.9%
associate-/l/62.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.6%
pow-plus75.6%
metadata-eval75.6%
associate-/r/75.6%
associate-/r/75.7%
Simplified75.7%
cbrt-prod85.9%
Applied egg-rr85.9%
Taylor expanded in k around 0 54.7%
unpow254.7%
associate-/l*58.3%
unpow258.3%
associate-*l*65.2%
Simplified65.2%
if -1.3999999999999999e-17 < t < 6.5000000000000003e-87Initial program 45.0%
associate-/r*45.0%
associate-*l*45.0%
sqr-neg45.0%
associate-*l*45.0%
*-commutative45.0%
sqr-neg45.0%
associate-*l/45.0%
associate-*r/45.0%
associate-/r/45.0%
Simplified45.0%
Taylor expanded in k around inf 77.9%
times-frac76.9%
unpow276.9%
unpow276.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in k around 0 69.3%
+-commutative69.3%
fma-def69.3%
unpow269.3%
associate-/l*69.5%
*-commutative69.5%
associate-/r*71.2%
unpow271.2%
associate-/l*74.8%
unpow274.8%
Simplified74.8%
Taylor expanded in t around -inf 69.5%
mul-1-neg69.5%
times-frac71.0%
distribute-rgt-neg-in71.0%
mul-1-neg71.0%
unsub-neg71.0%
*-commutative71.0%
unpow271.0%
associate-*l*71.0%
unpow271.0%
associate-/l*76.5%
unpow276.5%
unpow276.5%
Simplified76.5%
if 6.5000000000000003e-87 < t Initial program 66.2%
associate-/r*66.2%
associate-*l*59.0%
sqr-neg59.0%
associate-*l*66.2%
*-commutative66.2%
sqr-neg66.2%
associate-/r*66.2%
Simplified66.0%
associate-/l/66.0%
associate-/r/66.2%
add-cube-cbrt66.1%
Applied egg-rr77.4%
pow-plus77.4%
metadata-eval77.4%
associate-/r/77.5%
associate-/r/77.5%
Simplified77.5%
cbrt-prod88.9%
Applied egg-rr88.9%
cbrt-div96.5%
Applied egg-rr96.5%
Taylor expanded in k around 0 55.5%
associate-/r*56.6%
unpow256.6%
unpow256.6%
times-frac69.1%
Simplified69.1%
Final simplification71.3%
(FPCore (t l k) :precision binary64 (if (<= k 155000.0) (/ l (/ (* k (* k (pow t 3.0))) l)) (* 2.0 (* 0.3333333333333333 (* (/ (cos k) (* k k)) (* l (/ l t)))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 155000.0) {
tmp = l / ((k * (k * pow(t, 3.0))) / l);
} else {
tmp = 2.0 * (0.3333333333333333 * ((cos(k) / (k * k)) * (l * (l / 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 <= 155000.0d0) then
tmp = l / ((k * (k * (t ** 3.0d0))) / l)
else
tmp = 2.0d0 * (0.3333333333333333d0 * ((cos(k) / (k * k)) * (l * (l / t))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 155000.0) {
tmp = l / ((k * (k * Math.pow(t, 3.0))) / l);
} else {
tmp = 2.0 * (0.3333333333333333 * ((Math.cos(k) / (k * k)) * (l * (l / t))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 155000.0: tmp = l / ((k * (k * math.pow(t, 3.0))) / l) else: tmp = 2.0 * (0.3333333333333333 * ((math.cos(k) / (k * k)) * (l * (l / t)))) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 155000.0) tmp = Float64(l / Float64(Float64(k * Float64(k * (t ^ 3.0))) / l)); else tmp = Float64(2.0 * Float64(0.3333333333333333 * Float64(Float64(cos(k) / Float64(k * k)) * Float64(l * Float64(l / t))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 155000.0) tmp = l / ((k * (k * (t ^ 3.0))) / l); else tmp = 2.0 * (0.3333333333333333 * ((cos(k) / (k * k)) * (l * (l / t)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 155000.0], N[(l / N[(N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(0.3333333333333333 * N[(N[(N[Cos[k], $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l * N[(l / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 155000:\\
\;\;\;\;\frac{\ell}{\frac{k \cdot \left(k \cdot {t}^{3}\right)}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(0.3333333333333333 \cdot \left(\frac{\cos k}{k \cdot k} \cdot \left(\ell \cdot \frac{\ell}{t}\right)\right)\right)\\
\end{array}
\end{array}
if k < 155000Initial program 61.5%
associate-/r*61.5%
associate-*l*55.6%
sqr-neg55.6%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.5%
Simplified61.9%
associate-/l/61.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.5%
pow-plus75.5%
metadata-eval75.5%
associate-/r/75.5%
associate-/r/75.5%
Simplified75.5%
cbrt-prod80.8%
Applied egg-rr80.8%
Taylor expanded in k around 0 53.7%
unpow253.7%
associate-/l*57.9%
unpow257.9%
associate-*l*64.0%
Simplified64.0%
if 155000 < k Initial program 40.4%
associate-/r*40.4%
associate-*l*40.4%
sqr-neg40.4%
associate-*l*40.4%
*-commutative40.4%
sqr-neg40.4%
associate-*l/40.4%
associate-*r/40.4%
associate-/r/40.4%
Simplified40.4%
Taylor expanded in k around inf 78.2%
times-frac78.3%
unpow278.3%
unpow278.3%
*-commutative78.3%
Simplified78.3%
Taylor expanded in k around 0 69.5%
+-commutative69.5%
fma-def69.5%
unpow269.5%
associate-/l*69.5%
*-commutative69.5%
associate-/r*69.6%
unpow269.6%
associate-/l*72.7%
unpow272.7%
Simplified72.7%
Taylor expanded in k around inf 69.5%
times-frac69.6%
unpow269.6%
unpow269.6%
associate-*r/72.7%
Simplified72.7%
Final simplification66.2%
(FPCore (t l k) :precision binary64 (if (<= k 305000.0) (/ l (/ (* k (* k (pow t 3.0))) l)) (* 2.0 (/ (cos k) (* (/ 3.0 l) (/ (* t (* k k)) l))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 305000.0) {
tmp = l / ((k * (k * pow(t, 3.0))) / l);
} else {
tmp = 2.0 * (cos(k) / ((3.0 / l) * ((t * (k * k)) / 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 (k <= 305000.0d0) then
tmp = l / ((k * (k * (t ** 3.0d0))) / l)
else
tmp = 2.0d0 * (cos(k) / ((3.0d0 / l) * ((t * (k * k)) / l)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 305000.0) {
tmp = l / ((k * (k * Math.pow(t, 3.0))) / l);
} else {
tmp = 2.0 * (Math.cos(k) / ((3.0 / l) * ((t * (k * k)) / l)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 305000.0: tmp = l / ((k * (k * math.pow(t, 3.0))) / l) else: tmp = 2.0 * (math.cos(k) / ((3.0 / l) * ((t * (k * k)) / l))) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 305000.0) tmp = Float64(l / Float64(Float64(k * Float64(k * (t ^ 3.0))) / l)); else tmp = Float64(2.0 * Float64(cos(k) / Float64(Float64(3.0 / l) * Float64(Float64(t * Float64(k * k)) / l)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 305000.0) tmp = l / ((k * (k * (t ^ 3.0))) / l); else tmp = 2.0 * (cos(k) / ((3.0 / l) * ((t * (k * k)) / l))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 305000.0], N[(l / N[(N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Cos[k], $MachinePrecision] / N[(N[(3.0 / l), $MachinePrecision] * N[(N[(t * N[(k * k), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 305000:\\
\;\;\;\;\frac{\ell}{\frac{k \cdot \left(k \cdot {t}^{3}\right)}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\cos k}{\frac{3}{\ell} \cdot \frac{t \cdot \left(k \cdot k\right)}{\ell}}\\
\end{array}
\end{array}
if k < 305000Initial program 61.5%
associate-/r*61.5%
associate-*l*55.6%
sqr-neg55.6%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.5%
Simplified61.9%
associate-/l/61.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.5%
pow-plus75.5%
metadata-eval75.5%
associate-/r/75.5%
associate-/r/75.5%
Simplified75.5%
cbrt-prod80.8%
Applied egg-rr80.8%
Taylor expanded in k around 0 53.7%
unpow253.7%
associate-/l*57.9%
unpow257.9%
associate-*l*64.0%
Simplified64.0%
if 305000 < k Initial program 40.4%
associate-/r*40.4%
associate-*l*40.4%
sqr-neg40.4%
associate-*l*40.4%
*-commutative40.4%
sqr-neg40.4%
associate-*l/40.4%
associate-*r/40.4%
associate-/r/40.4%
Simplified40.4%
Taylor expanded in k around inf 78.2%
times-frac78.3%
unpow278.3%
unpow278.3%
*-commutative78.3%
Simplified78.3%
Taylor expanded in k around 0 69.5%
+-commutative69.5%
fma-def69.5%
unpow269.5%
associate-/l*69.5%
*-commutative69.5%
associate-/r*69.6%
unpow269.6%
associate-/l*72.7%
unpow272.7%
Simplified72.7%
Taylor expanded in l around 0 69.6%
associate-/l*69.6%
unpow269.6%
*-commutative69.6%
unpow269.6%
associate-*l*72.7%
associate-*r/72.7%
metadata-eval72.7%
*-commutative72.7%
associate-/r*72.7%
unpow272.7%
Simplified72.7%
Taylor expanded in k around inf 69.5%
associate-*r/69.5%
unpow269.5%
times-frac74.5%
unpow274.5%
Simplified74.5%
Final simplification66.7%
(FPCore (t l k)
:precision binary64
(if (<= t -1.12e-16)
(/ l (/ (* k (* k (pow t 3.0))) l))
(if (<= t 5.5e-91)
(* 2.0 (/ (* l (/ l (pow k 4.0))) t))
(/ (* (/ l k) (/ l k)) (pow t 3.0)))))
double code(double t, double l, double k) {
double tmp;
if (t <= -1.12e-16) {
tmp = l / ((k * (k * pow(t, 3.0))) / l);
} else if (t <= 5.5e-91) {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
} else {
tmp = ((l / k) * (l / k)) / pow(t, 3.0);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= (-1.12d-16)) then
tmp = l / ((k * (k * (t ** 3.0d0))) / l)
else if (t <= 5.5d-91) then
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
else
tmp = ((l / k) * (l / k)) / (t ** 3.0d0)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= -1.12e-16) {
tmp = l / ((k * (k * Math.pow(t, 3.0))) / l);
} else if (t <= 5.5e-91) {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
} else {
tmp = ((l / k) * (l / k)) / Math.pow(t, 3.0);
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= -1.12e-16: tmp = l / ((k * (k * math.pow(t, 3.0))) / l) elif t <= 5.5e-91: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) else: tmp = ((l / k) * (l / k)) / math.pow(t, 3.0) return tmp
function code(t, l, k) tmp = 0.0 if (t <= -1.12e-16) tmp = Float64(l / Float64(Float64(k * Float64(k * (t ^ 3.0))) / l)); elseif (t <= 5.5e-91) tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); else tmp = Float64(Float64(Float64(l / k) * Float64(l / k)) / (t ^ 3.0)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= -1.12e-16) tmp = l / ((k * (k * (t ^ 3.0))) / l); elseif (t <= 5.5e-91) tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); else tmp = ((l / k) * (l / k)) / (t ^ 3.0); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, -1.12e-16], N[(l / N[(N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e-91], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.12 \cdot 10^{-16}:\\
\;\;\;\;\frac{\ell}{\frac{k \cdot \left(k \cdot {t}^{3}\right)}{\ell}}\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{-91}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\ell}{k} \cdot \frac{\ell}{k}}{{t}^{3}}\\
\end{array}
\end{array}
if t < -1.12e-16Initial program 61.5%
associate-/r*61.5%
associate-*l*53.4%
sqr-neg53.4%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.4%
Simplified62.9%
associate-/l/62.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.6%
pow-plus75.6%
metadata-eval75.6%
associate-/r/75.6%
associate-/r/75.7%
Simplified75.7%
cbrt-prod85.9%
Applied egg-rr85.9%
Taylor expanded in k around 0 54.7%
unpow254.7%
associate-/l*58.3%
unpow258.3%
associate-*l*65.2%
Simplified65.2%
if -1.12e-16 < t < 5.49999999999999965e-91Initial program 45.0%
associate-/r*45.0%
associate-*l*45.0%
sqr-neg45.0%
associate-*l*45.0%
*-commutative45.0%
sqr-neg45.0%
associate-*l/45.0%
associate-*r/45.0%
associate-/r/45.0%
Simplified45.0%
Taylor expanded in k around inf 77.9%
times-frac76.9%
unpow276.9%
unpow276.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in k around 0 60.7%
unpow260.7%
*-commutative60.7%
Simplified60.7%
Taylor expanded in l around 0 60.7%
unpow260.7%
*-commutative60.7%
times-frac67.8%
Simplified67.8%
associate-*l/68.0%
Applied egg-rr68.0%
if 5.49999999999999965e-91 < t Initial program 66.2%
associate-/r*66.2%
associate-*l*59.0%
sqr-neg59.0%
associate-*l*66.2%
*-commutative66.2%
sqr-neg66.2%
associate-/r*66.2%
Simplified66.0%
associate-/l/66.0%
associate-/r/66.2%
add-cube-cbrt66.1%
Applied egg-rr77.4%
pow-plus77.4%
metadata-eval77.4%
associate-/r/77.5%
associate-/r/77.5%
Simplified77.5%
cbrt-prod88.9%
Applied egg-rr88.9%
cbrt-div96.5%
Applied egg-rr96.5%
Taylor expanded in k around 0 55.5%
associate-/r*56.6%
unpow256.6%
unpow256.6%
times-frac69.1%
Simplified69.1%
Final simplification67.6%
(FPCore (t l k) :precision binary64 (if (<= k 2000000.0) (* (/ l (pow t 3.0)) (/ l (* k k))) (* 2.0 (/ (* l (/ l (pow k 4.0))) t))))
double code(double t, double l, double k) {
double tmp;
if (k <= 2000000.0) {
tmp = (l / pow(t, 3.0)) * (l / (k * k));
} else {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 2000000.0d0) then
tmp = (l / (t ** 3.0d0)) * (l / (k * k))
else
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 2000000.0) {
tmp = (l / Math.pow(t, 3.0)) * (l / (k * k));
} else {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 2000000.0: tmp = (l / math.pow(t, 3.0)) * (l / (k * k)) else: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 2000000.0) tmp = Float64(Float64(l / (t ^ 3.0)) * Float64(l / Float64(k * k))); else tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 2000000.0) tmp = (l / (t ^ 3.0)) * (l / (k * k)); else tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 2000000.0], N[(N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] * N[(l / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 2000000:\\
\;\;\;\;\frac{\ell}{{t}^{3}} \cdot \frac{\ell}{k \cdot k}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\end{array}
\end{array}
if k < 2e6Initial program 61.5%
associate-/r*61.5%
associate-*l*55.6%
sqr-neg55.6%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-*l/62.0%
associate-*r/61.0%
associate-/r/61.3%
Simplified61.3%
Taylor expanded in k around 0 53.7%
unpow253.7%
unpow253.7%
Simplified53.7%
times-frac57.8%
Applied egg-rr57.8%
if 2e6 < k Initial program 40.4%
associate-/r*40.4%
associate-*l*40.4%
sqr-neg40.4%
associate-*l*40.4%
*-commutative40.4%
sqr-neg40.4%
associate-*l/40.4%
associate-*r/40.4%
associate-/r/40.4%
Simplified40.4%
Taylor expanded in k around inf 78.2%
times-frac78.3%
unpow278.3%
unpow278.3%
*-commutative78.3%
Simplified78.3%
Taylor expanded in k around 0 60.8%
unpow260.8%
*-commutative60.8%
Simplified60.8%
Taylor expanded in l around 0 60.8%
unpow260.8%
*-commutative60.8%
times-frac65.7%
Simplified65.7%
associate-*l/65.8%
Applied egg-rr65.8%
Final simplification59.9%
(FPCore (t l k) :precision binary64 (if (<= k 29500000.0) (/ l (/ (* k k) (/ l (pow t 3.0)))) (* 2.0 (/ (* l (/ l (pow k 4.0))) t))))
double code(double t, double l, double k) {
double tmp;
if (k <= 29500000.0) {
tmp = l / ((k * k) / (l / pow(t, 3.0)));
} else {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 29500000.0d0) then
tmp = l / ((k * k) / (l / (t ** 3.0d0)))
else
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 29500000.0) {
tmp = l / ((k * k) / (l / Math.pow(t, 3.0)));
} else {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 29500000.0: tmp = l / ((k * k) / (l / math.pow(t, 3.0))) else: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 29500000.0) tmp = Float64(l / Float64(Float64(k * k) / Float64(l / (t ^ 3.0)))); else tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 29500000.0) tmp = l / ((k * k) / (l / (t ^ 3.0))); else tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 29500000.0], N[(l / N[(N[(k * k), $MachinePrecision] / N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 29500000:\\
\;\;\;\;\frac{\ell}{\frac{k \cdot k}{\frac{\ell}{{t}^{3}}}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\end{array}
\end{array}
if k < 2.95e7Initial program 61.5%
associate-/r*61.5%
associate-*l*55.6%
sqr-neg55.6%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.5%
Simplified61.9%
associate-/l/61.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.5%
pow-plus75.5%
metadata-eval75.5%
associate-/r/75.5%
associate-/r/75.5%
Simplified75.5%
Taylor expanded in k around 0 53.7%
*-commutative53.7%
associate-/r*53.8%
unpow253.8%
associate-*r/57.2%
associate-/l*57.9%
unpow257.9%
Simplified57.9%
if 2.95e7 < k Initial program 40.4%
associate-/r*40.4%
associate-*l*40.4%
sqr-neg40.4%
associate-*l*40.4%
*-commutative40.4%
sqr-neg40.4%
associate-*l/40.4%
associate-*r/40.4%
associate-/r/40.4%
Simplified40.4%
Taylor expanded in k around inf 78.2%
times-frac78.3%
unpow278.3%
unpow278.3%
*-commutative78.3%
Simplified78.3%
Taylor expanded in k around 0 60.8%
unpow260.8%
*-commutative60.8%
Simplified60.8%
Taylor expanded in l around 0 60.8%
unpow260.8%
*-commutative60.8%
times-frac65.7%
Simplified65.7%
associate-*l/65.8%
Applied egg-rr65.8%
Final simplification60.0%
(FPCore (t l k) :precision binary64 (if (<= k 7500000.0) (/ l (/ (* k (* k (pow t 3.0))) l)) (* 2.0 (/ (* l (/ l (pow k 4.0))) t))))
double code(double t, double l, double k) {
double tmp;
if (k <= 7500000.0) {
tmp = l / ((k * (k * pow(t, 3.0))) / l);
} else {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 7500000.0d0) then
tmp = l / ((k * (k * (t ** 3.0d0))) / l)
else
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 7500000.0) {
tmp = l / ((k * (k * Math.pow(t, 3.0))) / l);
} else {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 7500000.0: tmp = l / ((k * (k * math.pow(t, 3.0))) / l) else: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 7500000.0) tmp = Float64(l / Float64(Float64(k * Float64(k * (t ^ 3.0))) / l)); else tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 7500000.0) tmp = l / ((k * (k * (t ^ 3.0))) / l); else tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 7500000.0], N[(l / N[(N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 7500000:\\
\;\;\;\;\frac{\ell}{\frac{k \cdot \left(k \cdot {t}^{3}\right)}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\end{array}
\end{array}
if k < 7.5e6Initial program 61.5%
associate-/r*61.5%
associate-*l*55.6%
sqr-neg55.6%
associate-*l*61.5%
*-commutative61.5%
sqr-neg61.5%
associate-/r*61.5%
Simplified61.9%
associate-/l/61.9%
associate-/r/61.5%
add-cube-cbrt61.4%
Applied egg-rr75.5%
pow-plus75.5%
metadata-eval75.5%
associate-/r/75.5%
associate-/r/75.5%
Simplified75.5%
cbrt-prod80.8%
Applied egg-rr80.8%
Taylor expanded in k around 0 53.7%
unpow253.7%
associate-/l*57.9%
unpow257.9%
associate-*l*64.0%
Simplified64.0%
if 7.5e6 < k Initial program 40.4%
associate-/r*40.4%
associate-*l*40.4%
sqr-neg40.4%
associate-*l*40.4%
*-commutative40.4%
sqr-neg40.4%
associate-*l/40.4%
associate-*r/40.4%
associate-/r/40.4%
Simplified40.4%
Taylor expanded in k around inf 78.2%
times-frac78.3%
unpow278.3%
unpow278.3%
*-commutative78.3%
Simplified78.3%
Taylor expanded in k around 0 60.8%
unpow260.8%
*-commutative60.8%
Simplified60.8%
Taylor expanded in l around 0 60.8%
unpow260.8%
*-commutative60.8%
times-frac65.7%
Simplified65.7%
associate-*l/65.8%
Applied egg-rr65.8%
Final simplification64.4%
(FPCore (t l k) :precision binary64 (* 2.0 (* (/ l t) (/ l (pow k 4.0)))))
double code(double t, double l, double k) {
return 2.0 * ((l / t) * (l / pow(k, 4.0)));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 * ((l / t) * (l / (k ** 4.0d0)))
end function
public static double code(double t, double l, double k) {
return 2.0 * ((l / t) * (l / Math.pow(k, 4.0)));
}
def code(t, l, k): return 2.0 * ((l / t) * (l / math.pow(k, 4.0)))
function code(t, l, k) return Float64(2.0 * Float64(Float64(l / t) * Float64(l / (k ^ 4.0)))) end
function tmp = code(t, l, k) tmp = 2.0 * ((l / t) * (l / (k ^ 4.0))); end
code[t_, l_, k_] := N[(2.0 * N[(N[(l / t), $MachinePrecision] * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\frac{\ell}{t} \cdot \frac{\ell}{{k}^{4}}\right)
\end{array}
Initial program 56.0%
associate-/r*56.0%
associate-*l*51.6%
sqr-neg51.6%
associate-*l*56.0%
*-commutative56.0%
sqr-neg56.0%
associate-*l/56.3%
associate-*r/55.6%
associate-/r/55.8%
Simplified55.8%
Taylor expanded in k around inf 61.0%
times-frac60.7%
unpow260.7%
unpow260.7%
*-commutative60.7%
Simplified60.7%
Taylor expanded in k around 0 53.5%
unpow253.5%
*-commutative53.5%
Simplified53.5%
Taylor expanded in l around 0 53.5%
unpow253.5%
*-commutative53.5%
times-frac57.8%
Simplified57.8%
Final simplification57.8%
(FPCore (t l k) :precision binary64 (* 2.0 (/ (* l (/ l (pow k 4.0))) t)))
double code(double t, double l, double k) {
return 2.0 * ((l * (l / 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 = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end function
public static double code(double t, double l, double k) {
return 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
def code(t, l, k): return 2.0 * ((l * (l / math.pow(k, 4.0))) / t)
function code(t, l, k) return Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)) end
function tmp = code(t, l, k) tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end
code[t_, l_, k_] := N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}
\end{array}
Initial program 56.0%
associate-/r*56.0%
associate-*l*51.6%
sqr-neg51.6%
associate-*l*56.0%
*-commutative56.0%
sqr-neg56.0%
associate-*l/56.3%
associate-*r/55.6%
associate-/r/55.8%
Simplified55.8%
Taylor expanded in k around inf 61.0%
times-frac60.7%
unpow260.7%
unpow260.7%
*-commutative60.7%
Simplified60.7%
Taylor expanded in k around 0 53.5%
unpow253.5%
*-commutative53.5%
Simplified53.5%
Taylor expanded in l around 0 53.5%
unpow253.5%
*-commutative53.5%
times-frac57.8%
Simplified57.8%
associate-*l/58.0%
Applied egg-rr58.0%
Final simplification58.0%
herbie shell --seed 2023274
(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))))