
(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 18 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 (cbrt (sin k))) (t_2 (+ 2.0 (/ (/ k t) (/ t k)))))
(if (<= t -9.5e-58)
(/ (/ 2.0 (* (pow (* (* t (pow (cbrt l) -2.0)) t_1) 3.0) (tan k))) t_2)
(if (<= t 4.4e-45)
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))
(/
(/ 2.0 (* (tan k) (pow (/ (* t t_1) (pow (cbrt l) 2.0)) 3.0)))
t_2)))))
double code(double t, double l, double k) {
double t_1 = cbrt(sin(k));
double t_2 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -9.5e-58) {
tmp = (2.0 / (pow(((t * pow(cbrt(l), -2.0)) * t_1), 3.0) * tan(k))) / t_2;
} else if (t <= 4.4e-45) {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
} else {
tmp = (2.0 / (tan(k) * pow(((t * t_1) / pow(cbrt(l), 2.0)), 3.0))) / t_2;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt(Math.sin(k));
double t_2 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -9.5e-58) {
tmp = (2.0 / (Math.pow(((t * Math.pow(Math.cbrt(l), -2.0)) * t_1), 3.0) * Math.tan(k))) / t_2;
} else if (t <= 4.4e-45) {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
} else {
tmp = (2.0 / (Math.tan(k) * Math.pow(((t * t_1) / Math.pow(Math.cbrt(l), 2.0)), 3.0))) / t_2;
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(sin(k)) t_2 = Float64(2.0 + Float64(Float64(k / t) / Float64(t / k))) tmp = 0.0 if (t <= -9.5e-58) tmp = Float64(Float64(2.0 / Float64((Float64(Float64(t * (cbrt(l) ^ -2.0)) * t_1) ^ 3.0) * tan(k))) / t_2); elseif (t <= 4.4e-45) tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); else tmp = Float64(Float64(2.0 / Float64(tan(k) * (Float64(Float64(t * t_1) / (cbrt(l) ^ 2.0)) ^ 3.0))) / t_2); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9.5e-58], N[(N[(2.0 / N[(N[Power[N[(N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], 3.0], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[t, 4.4e-45], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[Power[N[(N[(t * t$95$1), $MachinePrecision] / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\sin k}\\
t_2 := 2 + \frac{\frac{k}{t}}{\frac{t}{k}}\\
\mathbf{if}\;t \leq -9.5 \cdot 10^{-58}:\\
\;\;\;\;\frac{\frac{2}{{\left(\left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right) \cdot t_1\right)}^{3} \cdot \tan k}}{t_2}\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{-45}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot {\left(\frac{t \cdot t_1}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}}}{t_2}\\
\end{array}
\end{array}
if t < -9.4999999999999994e-58Initial program 62.6%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-cube-cbrt72.1%
pow372.1%
cbrt-prod72.0%
cbrt-div74.6%
cbrt-div74.5%
unpow374.5%
add-cbrt-cube94.9%
associate-/l/95.0%
pow295.0%
Applied egg-rr95.0%
expm1-log1p-u58.0%
expm1-udef39.5%
div-inv39.5%
pow-flip39.5%
metadata-eval39.5%
Applied egg-rr39.5%
expm1-def58.1%
expm1-log1p95.0%
Simplified95.0%
if -9.4999999999999994e-58 < t < 4.39999999999999987e-45Initial program 35.0%
Simplified33.2%
associate-*r*40.1%
*-un-lft-identity40.1%
times-frac40.1%
Applied egg-rr40.1%
/-rgt-identity40.1%
associate-*r/40.1%
times-frac41.0%
*-commutative41.0%
associate-/r*41.0%
Simplified41.0%
Taylor expanded in t around 0 78.8%
associate-*r/78.8%
times-frac80.9%
Simplified80.9%
if 4.39999999999999987e-45 < t Initial program 66.6%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-cube-cbrt72.1%
pow372.1%
cbrt-prod72.0%
cbrt-div73.3%
cbrt-div73.2%
unpow373.2%
add-cbrt-cube92.2%
associate-/l/92.2%
pow292.2%
Applied egg-rr92.2%
associate-*l/92.3%
Applied egg-rr92.3%
Final simplification88.5%
(FPCore (t l k)
:precision binary64
(if (<=
(/
2.0
(*
(+ 1.0 (+ 1.0 (pow (/ k t) 2.0)))
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))))
5e+301)
(/
(/ 2.0 (* (tan k) (* (sin k) (/ (* t (/ (pow t 2.0) l)) l))))
(+ 2.0 (/ (/ k t) (/ t k))))
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((2.0 / ((1.0 + (1.0 + pow((k / t), 2.0))) * (tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))))) <= 5e+301) {
tmp = (2.0 / (tan(k) * (sin(k) * ((t * (pow(t, 2.0) / l)) / l)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
}
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 ((2.0d0 / ((1.0d0 + (1.0d0 + ((k / t) ** 2.0d0))) * (tan(k) * (sin(k) * ((t ** 3.0d0) / (l * l)))))) <= 5d+301) then
tmp = (2.0d0 / (tan(k) * (sin(k) * ((t * ((t ** 2.0d0) / l)) / l)))) / (2.0d0 + ((k / t) / (t / k)))
else
tmp = ((2.0d0 / (k ** 2.0d0)) * (l / t)) * ((l / sin(k)) / tan(k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((2.0 / ((1.0 + (1.0 + Math.pow((k / t), 2.0))) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))))) <= 5e+301) {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * ((t * (Math.pow(t, 2.0) / l)) / l)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (2.0 / ((1.0 + (1.0 + math.pow((k / t), 2.0))) * (math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))))) <= 5e+301: tmp = (2.0 / (math.tan(k) * (math.sin(k) * ((t * (math.pow(t, 2.0) / l)) / l)))) / (2.0 + ((k / t) / (t / k))) else: tmp = ((2.0 / math.pow(k, 2.0)) * (l / t)) * ((l / math.sin(k)) / math.tan(k)) return tmp
function code(t, l, k) tmp = 0.0 if (Float64(2.0 / Float64(Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0))) * Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))))) <= 5e+301) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * Float64(Float64(t * Float64((t ^ 2.0) / l)) / l)))) / Float64(2.0 + Float64(Float64(k / t) / Float64(t / k)))); else tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((2.0 / ((1.0 + (1.0 + ((k / t) ^ 2.0))) * (tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))))) <= 5e+301) tmp = (2.0 / (tan(k) * (sin(k) * ((t * ((t ^ 2.0) / l)) / l)))) / (2.0 + ((k / t) / (t / k))); else tmp = ((2.0 / (k ^ 2.0)) * (l / t)) * ((l / sin(k)) / tan(k)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[N[(2.0 / N[(N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 5e+301], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(t * N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{2}{\left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq 5 \cdot 10^{+301}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot \frac{t \cdot \frac{{t}^{2}}{\ell}}{\ell}\right)}}{2 + \frac{\frac{k}{t}}{\frac{t}{k}}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\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))) < 5.0000000000000004e301Initial program 80.6%
Simplified85.4%
unpow285.4%
clear-num85.4%
un-div-inv85.4%
Applied egg-rr85.4%
cube-mult85.4%
*-un-lft-identity85.4%
times-frac88.2%
pow288.2%
Applied egg-rr88.2%
if 5.0000000000000004e301 < (/.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 19.1%
Simplified19.1%
associate-*r*29.2%
*-un-lft-identity29.2%
times-frac29.8%
Applied egg-rr29.8%
/-rgt-identity29.8%
associate-*r/29.2%
times-frac29.8%
*-commutative29.8%
associate-/r*29.8%
Simplified29.8%
Taylor expanded in t around 0 63.8%
associate-*r/63.8%
times-frac64.0%
Simplified64.0%
Final simplification77.2%
(FPCore (t l k)
:precision binary64
(if (or (<= t -3.3e-58) (not (<= t 1.35e-46)))
(/
(/ 2.0 (* (pow (* (* t (pow (cbrt l) -2.0)) (cbrt (sin k))) 3.0) (tan k)))
(+ 2.0 (/ (/ k t) (/ t k))))
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -3.3e-58) || !(t <= 1.35e-46)) {
tmp = (2.0 / (pow(((t * pow(cbrt(l), -2.0)) * cbrt(sin(k))), 3.0) * tan(k))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -3.3e-58) || !(t <= 1.35e-46)) {
tmp = (2.0 / (Math.pow(((t * Math.pow(Math.cbrt(l), -2.0)) * Math.cbrt(Math.sin(k))), 3.0) * Math.tan(k))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -3.3e-58) || !(t <= 1.35e-46)) tmp = Float64(Float64(2.0 / Float64((Float64(Float64(t * (cbrt(l) ^ -2.0)) * cbrt(sin(k))) ^ 3.0) * tan(k))) / Float64(2.0 + Float64(Float64(k / t) / Float64(t / k)))); else tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -3.3e-58], N[Not[LessEqual[t, 1.35e-46]], $MachinePrecision]], N[(N[(2.0 / N[(N[Power[N[(N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.3 \cdot 10^{-58} \lor \neg \left(t \leq 1.35 \cdot 10^{-46}\right):\\
\;\;\;\;\frac{\frac{2}{{\left(\left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right) \cdot \sqrt[3]{\sin k}\right)}^{3} \cdot \tan k}}{2 + \frac{\frac{k}{t}}{\frac{t}{k}}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -3.30000000000000026e-58 or 1.35e-46 < t Initial program 64.7%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-cube-cbrt72.1%
pow372.1%
cbrt-prod72.0%
cbrt-div73.9%
cbrt-div73.8%
unpow373.8%
add-cbrt-cube93.5%
associate-/l/93.5%
pow293.5%
Applied egg-rr93.5%
expm1-log1p-u56.2%
expm1-udef40.7%
div-inv40.7%
pow-flip40.7%
metadata-eval40.7%
Applied egg-rr40.7%
expm1-def56.2%
expm1-log1p93.5%
Simplified93.5%
if -3.30000000000000026e-58 < t < 1.35e-46Initial program 35.0%
Simplified33.2%
associate-*r*40.1%
*-un-lft-identity40.1%
times-frac40.1%
Applied egg-rr40.1%
/-rgt-identity40.1%
associate-*r/40.1%
times-frac41.0%
*-commutative41.0%
associate-/r*41.0%
Simplified41.0%
Taylor expanded in t around 0 78.8%
associate-*r/78.8%
times-frac80.9%
Simplified80.9%
Final simplification88.5%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (cbrt (sin k))) (t_2 (+ 2.0 (/ (/ k t) (/ t k)))))
(if (<= t -6.2e-58)
(/ (/ 2.0 (* (pow (* (* t (pow (cbrt l) -2.0)) t_1) 3.0) (tan k))) t_2)
(if (<= t 4.3e-47)
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))
(/
(/ 2.0 (* (tan k) (pow (* t_1 (/ t (pow (cbrt l) 2.0))) 3.0)))
t_2)))))
double code(double t, double l, double k) {
double t_1 = cbrt(sin(k));
double t_2 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -6.2e-58) {
tmp = (2.0 / (pow(((t * pow(cbrt(l), -2.0)) * t_1), 3.0) * tan(k))) / t_2;
} else if (t <= 4.3e-47) {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
} else {
tmp = (2.0 / (tan(k) * pow((t_1 * (t / pow(cbrt(l), 2.0))), 3.0))) / t_2;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt(Math.sin(k));
double t_2 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -6.2e-58) {
tmp = (2.0 / (Math.pow(((t * Math.pow(Math.cbrt(l), -2.0)) * t_1), 3.0) * Math.tan(k))) / t_2;
} else if (t <= 4.3e-47) {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
} else {
tmp = (2.0 / (Math.tan(k) * Math.pow((t_1 * (t / Math.pow(Math.cbrt(l), 2.0))), 3.0))) / t_2;
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(sin(k)) t_2 = Float64(2.0 + Float64(Float64(k / t) / Float64(t / k))) tmp = 0.0 if (t <= -6.2e-58) tmp = Float64(Float64(2.0 / Float64((Float64(Float64(t * (cbrt(l) ^ -2.0)) * t_1) ^ 3.0) * tan(k))) / t_2); elseif (t <= 4.3e-47) tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); else tmp = Float64(Float64(2.0 / Float64(tan(k) * (Float64(t_1 * Float64(t / (cbrt(l) ^ 2.0))) ^ 3.0))) / t_2); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.2e-58], N[(N[(2.0 / N[(N[Power[N[(N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], 3.0], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[t, 4.3e-47], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[Power[N[(t$95$1 * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\sin k}\\
t_2 := 2 + \frac{\frac{k}{t}}{\frac{t}{k}}\\
\mathbf{if}\;t \leq -6.2 \cdot 10^{-58}:\\
\;\;\;\;\frac{\frac{2}{{\left(\left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right) \cdot t_1\right)}^{3} \cdot \tan k}}{t_2}\\
\mathbf{elif}\;t \leq 4.3 \cdot 10^{-47}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot {\left(t_1 \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}}}{t_2}\\
\end{array}
\end{array}
if t < -6.1999999999999998e-58Initial program 62.6%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-cube-cbrt72.1%
pow372.1%
cbrt-prod72.0%
cbrt-div74.6%
cbrt-div74.5%
unpow374.5%
add-cbrt-cube94.9%
associate-/l/95.0%
pow295.0%
Applied egg-rr95.0%
expm1-log1p-u58.0%
expm1-udef39.5%
div-inv39.5%
pow-flip39.5%
metadata-eval39.5%
Applied egg-rr39.5%
expm1-def58.1%
expm1-log1p95.0%
Simplified95.0%
if -6.1999999999999998e-58 < t < 4.2999999999999998e-47Initial program 35.0%
Simplified33.2%
associate-*r*40.1%
*-un-lft-identity40.1%
times-frac40.1%
Applied egg-rr40.1%
/-rgt-identity40.1%
associate-*r/40.1%
times-frac41.0%
*-commutative41.0%
associate-/r*41.0%
Simplified41.0%
Taylor expanded in t around 0 78.8%
associate-*r/78.8%
times-frac80.9%
Simplified80.9%
if 4.2999999999999998e-47 < t Initial program 66.6%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-cube-cbrt72.1%
pow372.1%
cbrt-prod72.0%
cbrt-div73.3%
cbrt-div73.2%
unpow373.2%
add-cbrt-cube92.2%
associate-/l/92.2%
pow292.2%
Applied egg-rr92.2%
Final simplification88.5%
(FPCore (t l k)
:precision binary64
(if (<= t -3.5e-55)
(/
2.0
(*
(* (tan k) (* (sin k) (pow (/ (/ t (cbrt l)) (cbrt l)) 3.0)))
(+ 1.0 (+ 1.0 (pow (/ k t) 2.0)))))
(if (<= t 1.28e-45)
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))
(/
(/ 2.0 (* (tan k) (* (sin k) (pow (/ t (pow (cbrt l) 2.0)) 3.0))))
(+ 2.0 (/ (/ k t) (/ t k)))))))
double code(double t, double l, double k) {
double tmp;
if (t <= -3.5e-55) {
tmp = 2.0 / ((tan(k) * (sin(k) * pow(((t / cbrt(l)) / cbrt(l)), 3.0))) * (1.0 + (1.0 + pow((k / t), 2.0))));
} else if (t <= 1.28e-45) {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
} else {
tmp = (2.0 / (tan(k) * (sin(k) * pow((t / pow(cbrt(l), 2.0)), 3.0)))) / (2.0 + ((k / t) / (t / k)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= -3.5e-55) {
tmp = 2.0 / ((Math.tan(k) * (Math.sin(k) * Math.pow(((t / Math.cbrt(l)) / Math.cbrt(l)), 3.0))) * (1.0 + (1.0 + Math.pow((k / t), 2.0))));
} else if (t <= 1.28e-45) {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
} else {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)))) / (2.0 + ((k / t) / (t / k)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= -3.5e-55) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * (Float64(Float64(t / cbrt(l)) / cbrt(l)) ^ 3.0))) * Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0))))); elseif (t <= 1.28e-45) tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); else tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))) / Float64(2.0 + Float64(Float64(k / t) / Float64(t / k)))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, -3.5e-55], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision] / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.28e-45], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.5 \cdot 10^{-55}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot {\left(\frac{\frac{t}{\sqrt[3]{\ell}}}{\sqrt[3]{\ell}}\right)}^{3}\right)\right) \cdot \left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right)}\\
\mathbf{elif}\;t \leq 1.28 \cdot 10^{-45}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}}{2 + \frac{\frac{k}{t}}{\frac{t}{k}}}\\
\end{array}
\end{array}
if t < -3.50000000000000025e-55Initial program 64.3%
associate-/r*74.2%
add-cube-cbrt74.2%
*-un-lft-identity74.2%
times-frac74.2%
pow274.2%
cbrt-div74.1%
rem-cbrt-cube74.1%
cbrt-div74.1%
rem-cbrt-cube88.8%
Applied egg-rr88.8%
add-cube-cbrt88.6%
pow388.7%
frac-times81.9%
unpow281.9%
*-un-lft-identity81.9%
cbrt-div81.9%
add-cbrt-cube91.3%
Applied egg-rr91.3%
if -3.50000000000000025e-55 < t < 1.28e-45Initial program 34.3%
Simplified32.5%
associate-*r*39.3%
*-un-lft-identity39.3%
times-frac39.3%
Applied egg-rr39.3%
/-rgt-identity39.3%
associate-*r/39.3%
times-frac40.3%
*-commutative40.3%
associate-/r*41.2%
Simplified41.2%
Taylor expanded in t around 0 77.4%
associate-*r/77.4%
times-frac79.5%
Simplified79.5%
if 1.28e-45 < t Initial program 66.6%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-cube-cbrt72.1%
pow372.0%
cbrt-div72.1%
cbrt-div72.0%
unpow372.0%
add-cbrt-cube87.5%
associate-/l/87.5%
pow287.5%
Applied egg-rr87.5%
Final simplification85.3%
(FPCore (t l k)
:precision binary64
(if (or (<= t -7.5e-51) (not (<= t 2e-43)))
(/
(/ 2.0 (* (tan k) (* (sin k) (pow (/ t (pow (cbrt l) 2.0)) 3.0))))
(+ 2.0 (/ (/ k t) (/ t k))))
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -7.5e-51) || !(t <= 2e-43)) {
tmp = (2.0 / (tan(k) * (sin(k) * pow((t / pow(cbrt(l), 2.0)), 3.0)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -7.5e-51) || !(t <= 2e-43)) {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -7.5e-51) || !(t <= 2e-43)) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))) / Float64(2.0 + Float64(Float64(k / t) / Float64(t / k)))); else tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -7.5e-51], N[Not[LessEqual[t, 2e-43]], $MachinePrecision]], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7.5 \cdot 10^{-51} \lor \neg \left(t \leq 2 \cdot 10^{-43}\right):\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}}{2 + \frac{\frac{k}{t}}{\frac{t}{k}}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -7.49999999999999976e-51 or 2.00000000000000015e-43 < t Initial program 65.5%
Simplified73.1%
unpow273.1%
clear-num73.1%
un-div-inv73.1%
Applied egg-rr73.1%
add-cube-cbrt73.0%
pow373.0%
cbrt-div73.0%
cbrt-div72.9%
unpow372.9%
add-cbrt-cube89.3%
associate-/l/89.3%
pow289.3%
Applied egg-rr89.3%
if -7.49999999999999976e-51 < t < 2.00000000000000015e-43Initial program 34.3%
Simplified32.5%
associate-*r*39.3%
*-un-lft-identity39.3%
times-frac39.3%
Applied egg-rr39.3%
/-rgt-identity39.3%
associate-*r/39.3%
times-frac40.3%
*-commutative40.3%
associate-/r*41.2%
Simplified41.2%
Taylor expanded in t around 0 77.4%
associate-*r/77.4%
times-frac79.5%
Simplified79.5%
Final simplification85.3%
(FPCore (t l k)
:precision binary64
(if (or (<= t -2.15e-36) (not (<= t 5e-45)))
(/
2.0
(*
(+ 1.0 (+ 1.0 (pow (/ k t) 2.0)))
(* (tan k) (* (sin k) (pow (* t (pow l -0.6666666666666666)) 3.0)))))
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -2.15e-36) || !(t <= 5e-45)) {
tmp = 2.0 / ((1.0 + (1.0 + pow((k / t), 2.0))) * (tan(k) * (sin(k) * pow((t * pow(l, -0.6666666666666666)), 3.0))));
} else {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
}
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.15d-36)) .or. (.not. (t <= 5d-45))) then
tmp = 2.0d0 / ((1.0d0 + (1.0d0 + ((k / t) ** 2.0d0))) * (tan(k) * (sin(k) * ((t * (l ** (-0.6666666666666666d0))) ** 3.0d0))))
else
tmp = ((2.0d0 / (k ** 2.0d0)) * (l / t)) * ((l / sin(k)) / tan(k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -2.15e-36) || !(t <= 5e-45)) {
tmp = 2.0 / ((1.0 + (1.0 + Math.pow((k / t), 2.0))) * (Math.tan(k) * (Math.sin(k) * Math.pow((t * Math.pow(l, -0.6666666666666666)), 3.0))));
} else {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -2.15e-36) or not (t <= 5e-45): tmp = 2.0 / ((1.0 + (1.0 + math.pow((k / t), 2.0))) * (math.tan(k) * (math.sin(k) * math.pow((t * math.pow(l, -0.6666666666666666)), 3.0)))) else: tmp = ((2.0 / math.pow(k, 2.0)) * (l / t)) * ((l / math.sin(k)) / math.tan(k)) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -2.15e-36) || !(t <= 5e-45)) tmp = Float64(2.0 / Float64(Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0))) * Float64(tan(k) * Float64(sin(k) * (Float64(t * (l ^ -0.6666666666666666)) ^ 3.0))))); else tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -2.15e-36) || ~((t <= 5e-45))) tmp = 2.0 / ((1.0 + (1.0 + ((k / t) ^ 2.0))) * (tan(k) * (sin(k) * ((t * (l ^ -0.6666666666666666)) ^ 3.0)))); else tmp = ((2.0 / (k ^ 2.0)) * (l / t)) * ((l / sin(k)) / tan(k)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -2.15e-36], N[Not[LessEqual[t, 5e-45]], $MachinePrecision]], N[(2.0 / N[(N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t * N[Power[l, -0.6666666666666666], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.15 \cdot 10^{-36} \lor \neg \left(t \leq 5 \cdot 10^{-45}\right):\\
\;\;\;\;\frac{2}{\left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot {\left(t \cdot {\ell}^{-0.6666666666666666}\right)}^{3}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -2.1500000000000001e-36 or 4.99999999999999976e-45 < t Initial program 65.4%
add-cube-cbrt65.4%
pow365.4%
div-inv65.4%
cbrt-prod65.3%
rem-cbrt-cube72.4%
pow272.4%
pow-flip72.6%
metadata-eval72.6%
Applied egg-rr72.6%
pow1/371.7%
pow-pow40.4%
metadata-eval40.4%
Applied egg-rr40.4%
if -2.1500000000000001e-36 < t < 4.99999999999999976e-45Initial program 35.3%
Simplified33.5%
associate-*r*41.0%
*-un-lft-identity41.0%
times-frac41.0%
Applied egg-rr41.0%
/-rgt-identity41.0%
associate-*r/41.0%
times-frac41.9%
*-commutative41.9%
associate-/r*42.8%
Simplified42.8%
Taylor expanded in t around 0 78.0%
associate-*r/78.0%
times-frac80.0%
Simplified80.0%
Final simplification57.1%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (+ 2.0 (/ (/ k t) (/ t k)))))
(if (<= t -2.1e+169)
(/ (/ 2.0 (* (tan k) (/ k (pow (/ (pow (cbrt l) 2.0) t) 3.0)))) t_1)
(if (<= t -1.4e-49)
(/
2.0
(*
(+ 1.0 (+ 1.0 (pow (/ k t) 2.0)))
(* (tan k) (* (sin k) (* (/ (pow t 2.0) l) (/ t l))))))
(if (<= t 1.3e-45)
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))
(/
(/
2.0
(* (tan k) (* (sin k) (/ (* (pow t 1.5) (/ (pow t 1.5) l)) l))))
t_1))))))
double code(double t, double l, double k) {
double t_1 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -2.1e+169) {
tmp = (2.0 / (tan(k) * (k / pow((pow(cbrt(l), 2.0) / t), 3.0)))) / t_1;
} else if (t <= -1.4e-49) {
tmp = 2.0 / ((1.0 + (1.0 + pow((k / t), 2.0))) * (tan(k) * (sin(k) * ((pow(t, 2.0) / l) * (t / l)))));
} else if (t <= 1.3e-45) {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
} else {
tmp = (2.0 / (tan(k) * (sin(k) * ((pow(t, 1.5) * (pow(t, 1.5) / l)) / l)))) / t_1;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -2.1e+169) {
tmp = (2.0 / (Math.tan(k) * (k / Math.pow((Math.pow(Math.cbrt(l), 2.0) / t), 3.0)))) / t_1;
} else if (t <= -1.4e-49) {
tmp = 2.0 / ((1.0 + (1.0 + Math.pow((k / t), 2.0))) * (Math.tan(k) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l)))));
} else if (t <= 1.3e-45) {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
} else {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * ((Math.pow(t, 1.5) * (Math.pow(t, 1.5) / l)) / l)))) / t_1;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(2.0 + Float64(Float64(k / t) / Float64(t / k))) tmp = 0.0 if (t <= -2.1e+169) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(k / (Float64((cbrt(l) ^ 2.0) / t) ^ 3.0)))) / t_1); elseif (t <= -1.4e-49) tmp = Float64(2.0 / Float64(Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0))) * Float64(tan(k) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))))); elseif (t <= 1.3e-45) tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); else tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * Float64(Float64((t ^ 1.5) * Float64((t ^ 1.5) / l)) / l)))) / t_1); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.1e+169], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(k / N[Power[N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[t, -1.4e-49], N[(2.0 / N[(N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.3e-45], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 1.5], $MachinePrecision] * N[(N[Power[t, 1.5], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 + \frac{\frac{k}{t}}{\frac{t}{k}}\\
\mathbf{if}\;t \leq -2.1 \cdot 10^{+169}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \frac{k}{{\left(\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t}\right)}^{3}}}}{t_1}\\
\mathbf{elif}\;t \leq -1.4 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)\right)}\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{-45}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot \frac{{t}^{1.5} \cdot \frac{{t}^{1.5}}{\ell}}{\ell}\right)}}{t_1}\\
\end{array}
\end{array}
if t < -2.1000000000000001e169Initial program 62.3%
Simplified68.8%
unpow268.8%
clear-num68.8%
un-div-inv68.8%
Applied egg-rr68.8%
Taylor expanded in k around 0 62.3%
associate-/l*62.3%
Simplified62.3%
add-cube-cbrt62.3%
pow262.3%
cbrt-div62.3%
unpow262.3%
cbrt-prod62.3%
unpow262.3%
unpow362.3%
add-cbrt-cube62.3%
cbrt-div62.3%
unpow262.3%
cbrt-prod68.8%
unpow268.8%
unpow368.8%
add-cbrt-cube82.6%
Applied egg-rr82.6%
pow-plus82.6%
metadata-eval82.6%
Simplified82.6%
if -2.1000000000000001e169 < t < -1.39999999999999999e-49Initial program 66.1%
unpow366.1%
times-frac94.4%
pow294.4%
Applied egg-rr94.4%
if -1.39999999999999999e-49 < t < 1.29999999999999993e-45Initial program 34.3%
Simplified32.5%
associate-*r*39.3%
*-un-lft-identity39.3%
times-frac39.3%
Applied egg-rr39.3%
/-rgt-identity39.3%
associate-*r/39.3%
times-frac40.3%
*-commutative40.3%
associate-/r*41.2%
Simplified41.2%
Taylor expanded in t around 0 77.4%
associate-*r/77.4%
times-frac79.5%
Simplified79.5%
if 1.29999999999999993e-45 < t Initial program 66.6%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-sqr-sqrt72.2%
*-un-lft-identity72.2%
times-frac72.2%
sqrt-pow172.2%
metadata-eval72.2%
sqrt-pow181.9%
metadata-eval81.9%
Applied egg-rr81.9%
Final simplification82.8%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (+ 2.0 (/ (/ k t) (/ t k)))))
(if (<= t -5e+169)
(/ (/ 2.0 (* (tan k) (/ k (pow (/ (pow (cbrt l) 2.0) t) 3.0)))) t_1)
(if (<= t -1.8e-49)
(/
2.0
(*
(+ 1.0 (+ 1.0 (pow (/ k t) 2.0)))
(* (tan k) (* (sin k) (* (/ (pow t 2.0) l) (/ t l))))))
(if (<= t 5.5e-46)
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))
(/
(/ 2.0 (* (tan k) (* (sin k) (/ (pow (/ t (cbrt l)) 3.0) l))))
t_1))))))
double code(double t, double l, double k) {
double t_1 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -5e+169) {
tmp = (2.0 / (tan(k) * (k / pow((pow(cbrt(l), 2.0) / t), 3.0)))) / t_1;
} else if (t <= -1.8e-49) {
tmp = 2.0 / ((1.0 + (1.0 + pow((k / t), 2.0))) * (tan(k) * (sin(k) * ((pow(t, 2.0) / l) * (t / l)))));
} else if (t <= 5.5e-46) {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
} else {
tmp = (2.0 / (tan(k) * (sin(k) * (pow((t / cbrt(l)), 3.0) / l)))) / t_1;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = 2.0 + ((k / t) / (t / k));
double tmp;
if (t <= -5e+169) {
tmp = (2.0 / (Math.tan(k) * (k / Math.pow((Math.pow(Math.cbrt(l), 2.0) / t), 3.0)))) / t_1;
} else if (t <= -1.8e-49) {
tmp = 2.0 / ((1.0 + (1.0 + Math.pow((k / t), 2.0))) * (Math.tan(k) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l)))));
} else if (t <= 5.5e-46) {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
} else {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * (Math.pow((t / Math.cbrt(l)), 3.0) / l)))) / t_1;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(2.0 + Float64(Float64(k / t) / Float64(t / k))) tmp = 0.0 if (t <= -5e+169) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(k / (Float64((cbrt(l) ^ 2.0) / t) ^ 3.0)))) / t_1); elseif (t <= -1.8e-49) tmp = Float64(2.0 / Float64(Float64(1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0))) * Float64(tan(k) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))))); elseif (t <= 5.5e-46) tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); else tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * Float64((Float64(t / cbrt(l)) ^ 3.0) / l)))) / t_1); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5e+169], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(k / N[Power[N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[t, -1.8e-49], N[(2.0 / N[(N[(1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e-46], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 + \frac{\frac{k}{t}}{\frac{t}{k}}\\
\mathbf{if}\;t \leq -5 \cdot 10^{+169}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \frac{k}{{\left(\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t}\right)}^{3}}}}{t_1}\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)\right)}\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{-46}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot \frac{{\left(\frac{t}{\sqrt[3]{\ell}}\right)}^{3}}{\ell}\right)}}{t_1}\\
\end{array}
\end{array}
if t < -5.00000000000000017e169Initial program 62.3%
Simplified68.8%
unpow268.8%
clear-num68.8%
un-div-inv68.8%
Applied egg-rr68.8%
Taylor expanded in k around 0 62.3%
associate-/l*62.3%
Simplified62.3%
add-cube-cbrt62.3%
pow262.3%
cbrt-div62.3%
unpow262.3%
cbrt-prod62.3%
unpow262.3%
unpow362.3%
add-cbrt-cube62.3%
cbrt-div62.3%
unpow262.3%
cbrt-prod68.8%
unpow268.8%
unpow368.8%
add-cbrt-cube82.6%
Applied egg-rr82.6%
pow-plus82.6%
metadata-eval82.6%
Simplified82.6%
if -5.00000000000000017e169 < t < -1.79999999999999985e-49Initial program 66.1%
unpow366.1%
times-frac94.4%
pow294.4%
Applied egg-rr94.4%
if -1.79999999999999985e-49 < t < 5.49999999999999983e-46Initial program 34.3%
Simplified32.5%
associate-*r*39.3%
*-un-lft-identity39.3%
times-frac39.3%
Applied egg-rr39.3%
/-rgt-identity39.3%
associate-*r/39.3%
times-frac40.3%
*-commutative40.3%
associate-/r*41.2%
Simplified41.2%
Taylor expanded in t around 0 77.4%
associate-*r/77.4%
times-frac79.5%
Simplified79.5%
if 5.49999999999999983e-46 < t Initial program 66.6%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
add-cube-cbrt72.1%
pow372.1%
cbrt-div72.0%
rem-cbrt-cube81.7%
Applied egg-rr81.7%
Final simplification82.7%
(FPCore (t l k)
:precision binary64
(if (<= k 7.2e-12)
(/
(/ 2.0 (* (tan k) (/ k (pow (/ (pow (cbrt l) 2.0) t) 3.0))))
(+ 2.0 (/ (/ k t) (/ t k))))
(* (/ (/ l (sin k)) (tan k)) (* 2.0 (/ l (* t (pow k 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 7.2e-12) {
tmp = (2.0 / (tan(k) * (k / pow((pow(cbrt(l), 2.0) / t), 3.0)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((l / sin(k)) / tan(k)) * (2.0 * (l / (t * pow(k, 2.0))));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (k <= 7.2e-12) {
tmp = (2.0 / (Math.tan(k) * (k / Math.pow((Math.pow(Math.cbrt(l), 2.0) / t), 3.0)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((l / Math.sin(k)) / Math.tan(k)) * (2.0 * (l / (t * Math.pow(k, 2.0))));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (k <= 7.2e-12) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(k / (Float64((cbrt(l) ^ 2.0) / t) ^ 3.0)))) / Float64(2.0 + Float64(Float64(k / t) / Float64(t / k)))); else tmp = Float64(Float64(Float64(l / sin(k)) / tan(k)) * Float64(2.0 * Float64(l / Float64(t * (k ^ 2.0))))); end return tmp end
code[t_, l_, k_] := If[LessEqual[k, 7.2e-12], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(k / N[Power[N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(l / N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 7.2 \cdot 10^{-12}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \frac{k}{{\left(\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t}\right)}^{3}}}}{2 + \frac{\frac{k}{t}}{\frac{t}{k}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\ell}{\sin k}}{\tan k} \cdot \left(2 \cdot \frac{\ell}{t \cdot {k}^{2}}\right)\\
\end{array}
\end{array}
if k < 7.2e-12Initial program 54.2%
Simplified61.3%
unpow261.3%
clear-num61.4%
un-div-inv61.4%
Applied egg-rr61.4%
Taylor expanded in k around 0 52.8%
associate-/l*52.6%
Simplified52.6%
add-cube-cbrt52.6%
pow252.6%
cbrt-div52.6%
unpow252.6%
cbrt-prod52.6%
unpow252.6%
unpow352.5%
add-cbrt-cube52.6%
cbrt-div52.6%
unpow252.6%
cbrt-prod59.7%
unpow259.7%
unpow359.7%
add-cbrt-cube72.1%
Applied egg-rr72.1%
pow-plus72.1%
metadata-eval72.1%
Simplified72.1%
if 7.2e-12 < k Initial program 48.7%
Simplified48.6%
associate-*r*56.1%
*-un-lft-identity56.1%
times-frac56.2%
Applied egg-rr56.2%
/-rgt-identity56.2%
associate-*r/56.1%
times-frac56.1%
*-commutative56.1%
associate-/r*56.2%
Simplified56.2%
Taylor expanded in t around 0 73.1%
Final simplification72.3%
(FPCore (t l k)
:precision binary64
(if (or (<= t -5.8e-49) (not (<= t 1.1e-44)))
(/
(/ 2.0 (* (tan k) (* (sin k) (/ (/ (pow t 3.0) l) l))))
(+ 2.0 (/ (/ k t) (/ t k))))
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -5.8e-49) || !(t <= 1.1e-44)) {
tmp = (2.0 / (tan(k) * (sin(k) * ((pow(t, 3.0) / l) / l)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
}
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 <= (-5.8d-49)) .or. (.not. (t <= 1.1d-44))) then
tmp = (2.0d0 / (tan(k) * (sin(k) * (((t ** 3.0d0) / l) / l)))) / (2.0d0 + ((k / t) / (t / k)))
else
tmp = ((2.0d0 / (k ** 2.0d0)) * (l / t)) * ((l / sin(k)) / tan(k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -5.8e-49) || !(t <= 1.1e-44)) {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * ((Math.pow(t, 3.0) / l) / l)))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -5.8e-49) or not (t <= 1.1e-44): tmp = (2.0 / (math.tan(k) * (math.sin(k) * ((math.pow(t, 3.0) / l) / l)))) / (2.0 + ((k / t) / (t / k))) else: tmp = ((2.0 / math.pow(k, 2.0)) * (l / t)) * ((l / math.sin(k)) / math.tan(k)) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -5.8e-49) || !(t <= 1.1e-44)) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * Float64(Float64((t ^ 3.0) / l) / l)))) / Float64(2.0 + Float64(Float64(k / t) / Float64(t / k)))); else tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -5.8e-49) || ~((t <= 1.1e-44))) tmp = (2.0 / (tan(k) * (sin(k) * (((t ^ 3.0) / l) / l)))) / (2.0 + ((k / t) / (t / k))); else tmp = ((2.0 / (k ^ 2.0)) * (l / t)) * ((l / sin(k)) / tan(k)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -5.8e-49], N[Not[LessEqual[t, 1.1e-44]], $MachinePrecision]], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5.8 \cdot 10^{-49} \lor \neg \left(t \leq 1.1 \cdot 10^{-44}\right):\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot \frac{\frac{{t}^{3}}{\ell}}{\ell}\right)}}{2 + \frac{\frac{k}{t}}{\frac{t}{k}}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -5.8e-49 or 1.10000000000000006e-44 < t Initial program 65.5%
Simplified73.1%
unpow273.1%
clear-num73.1%
un-div-inv73.1%
Applied egg-rr73.1%
if -5.8e-49 < t < 1.10000000000000006e-44Initial program 34.3%
Simplified32.5%
associate-*r*39.3%
*-un-lft-identity39.3%
times-frac39.3%
Applied egg-rr39.3%
/-rgt-identity39.3%
associate-*r/39.3%
times-frac40.3%
*-commutative40.3%
associate-/r*41.2%
Simplified41.2%
Taylor expanded in t around 0 77.4%
associate-*r/77.4%
times-frac79.5%
Simplified79.5%
Final simplification75.7%
(FPCore (t l k)
:precision binary64
(if (or (<= t -7e-57) (not (<= t 7.5e-45)))
(/
(/ 2.0 (* (tan k) (/ (* (sin k) (/ (pow t 3.0) l)) l)))
(+ 2.0 (/ (/ k t) (/ t k))))
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -7e-57) || !(t <= 7.5e-45)) {
tmp = (2.0 / (tan(k) * ((sin(k) * (pow(t, 3.0) / l)) / l))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / pow(k, 2.0)) * (l / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((t <= (-7d-57)) .or. (.not. (t <= 7.5d-45))) then
tmp = (2.0d0 / (tan(k) * ((sin(k) * ((t ** 3.0d0) / l)) / l))) / (2.0d0 + ((k / t) / (t / k)))
else
tmp = ((2.0d0 / (k ** 2.0d0)) * (l / t)) * ((l / sin(k)) / tan(k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -7e-57) || !(t <= 7.5e-45)) {
tmp = (2.0 / (Math.tan(k) * ((Math.sin(k) * (Math.pow(t, 3.0) / l)) / l))) / (2.0 + ((k / t) / (t / k)));
} else {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -7e-57) or not (t <= 7.5e-45): tmp = (2.0 / (math.tan(k) * ((math.sin(k) * (math.pow(t, 3.0) / l)) / l))) / (2.0 + ((k / t) / (t / k))) else: tmp = ((2.0 / math.pow(k, 2.0)) * (l / t)) * ((l / math.sin(k)) / math.tan(k)) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -7e-57) || !(t <= 7.5e-45)) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(Float64(sin(k) * Float64((t ^ 3.0) / l)) / l))) / Float64(2.0 + Float64(Float64(k / t) / Float64(t / k)))); else tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -7e-57) || ~((t <= 7.5e-45))) tmp = (2.0 / (tan(k) * ((sin(k) * ((t ^ 3.0) / l)) / l))) / (2.0 + ((k / t) / (t / k))); else tmp = ((2.0 / (k ^ 2.0)) * (l / t)) * ((l / sin(k)) / tan(k)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -7e-57], N[Not[LessEqual[t, 7.5e-45]], $MachinePrecision]], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7 \cdot 10^{-57} \lor \neg \left(t \leq 7.5 \cdot 10^{-45}\right):\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \frac{\sin k \cdot \frac{{t}^{3}}{\ell}}{\ell}}}{2 + \frac{\frac{k}{t}}{\frac{t}{k}}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -6.99999999999999983e-57 or 7.5000000000000006e-45 < t Initial program 64.7%
Simplified72.2%
unpow272.2%
clear-num72.2%
un-div-inv72.2%
Applied egg-rr72.2%
associate-*l/74.1%
Applied egg-rr74.1%
if -6.99999999999999983e-57 < t < 7.5000000000000006e-45Initial program 35.0%
Simplified33.2%
associate-*r*40.1%
*-un-lft-identity40.1%
times-frac40.1%
Applied egg-rr40.1%
/-rgt-identity40.1%
associate-*r/40.1%
times-frac41.0%
*-commutative41.0%
associate-/r*41.0%
Simplified41.0%
Taylor expanded in t around 0 78.8%
associate-*r/78.8%
times-frac80.9%
Simplified80.9%
Final simplification76.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ (/ l (sin k)) (tan k))))
(if (or (<= t -8e-34) (not (<= t 7.2e+133)))
(* t_1 (/ l (pow t 3.0)))
(* t_1 (* 2.0 (/ l (* t (pow k 2.0))))))))
double code(double t, double l, double k) {
double t_1 = (l / sin(k)) / tan(k);
double tmp;
if ((t <= -8e-34) || !(t <= 7.2e+133)) {
tmp = t_1 * (l / pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (t * pow(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 = (l / sin(k)) / tan(k)
if ((t <= (-8d-34)) .or. (.not. (t <= 7.2d+133))) then
tmp = t_1 * (l / (t ** 3.0d0))
else
tmp = t_1 * (2.0d0 * (l / (t * (k ** 2.0d0))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = (l / Math.sin(k)) / Math.tan(k);
double tmp;
if ((t <= -8e-34) || !(t <= 7.2e+133)) {
tmp = t_1 * (l / Math.pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (t * Math.pow(k, 2.0))));
}
return tmp;
}
def code(t, l, k): t_1 = (l / math.sin(k)) / math.tan(k) tmp = 0 if (t <= -8e-34) or not (t <= 7.2e+133): tmp = t_1 * (l / math.pow(t, 3.0)) else: tmp = t_1 * (2.0 * (l / (t * math.pow(k, 2.0)))) return tmp
function code(t, l, k) t_1 = Float64(Float64(l / sin(k)) / tan(k)) tmp = 0.0 if ((t <= -8e-34) || !(t <= 7.2e+133)) tmp = Float64(t_1 * Float64(l / (t ^ 3.0))); else tmp = Float64(t_1 * Float64(2.0 * Float64(l / Float64(t * (k ^ 2.0))))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (l / sin(k)) / tan(k); tmp = 0.0; if ((t <= -8e-34) || ~((t <= 7.2e+133))) tmp = t_1 * (l / (t ^ 3.0)); else tmp = t_1 * (2.0 * (l / (t * (k ^ 2.0)))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t, -8e-34], N[Not[LessEqual[t, 7.2e+133]], $MachinePrecision]], N[(t$95$1 * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(2.0 * N[(l / N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{if}\;t \leq -8 \cdot 10^{-34} \lor \neg \left(t \leq 7.2 \cdot 10^{+133}\right):\\
\;\;\;\;t_1 \cdot \frac{\ell}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \left(2 \cdot \frac{\ell}{t \cdot {k}^{2}}\right)\\
\end{array}
\end{array}
if t < -7.99999999999999942e-34 or 7.19999999999999956e133 < t Initial program 61.4%
Simplified53.4%
associate-*r*61.5%
*-un-lft-identity61.5%
times-frac62.0%
Applied egg-rr62.0%
/-rgt-identity62.0%
associate-*r/61.5%
times-frac62.0%
*-commutative62.0%
associate-/r*67.9%
Simplified67.9%
Taylor expanded in t around inf 64.9%
if -7.99999999999999942e-34 < t < 7.19999999999999956e133Initial program 45.5%
Simplified42.8%
associate-*r*48.6%
*-un-lft-identity48.6%
times-frac49.3%
Applied egg-rr49.3%
/-rgt-identity49.3%
associate-*r/48.6%
times-frac50.0%
*-commutative50.0%
associate-/r*51.3%
Simplified51.3%
Taylor expanded in t around 0 77.5%
Final simplification71.8%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ (/ l (sin k)) (tan k))))
(if (or (<= t -2.5e-36) (not (<= t 2.8e+144)))
(* t_1 (/ l (pow t 3.0)))
(* (* (/ 2.0 (pow k 2.0)) (/ l t)) t_1))))
double code(double t, double l, double k) {
double t_1 = (l / sin(k)) / tan(k);
double tmp;
if ((t <= -2.5e-36) || !(t <= 2.8e+144)) {
tmp = t_1 * (l / pow(t, 3.0));
} else {
tmp = ((2.0 / pow(k, 2.0)) * (l / 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 = (l / sin(k)) / tan(k)
if ((t <= (-2.5d-36)) .or. (.not. (t <= 2.8d+144))) then
tmp = t_1 * (l / (t ** 3.0d0))
else
tmp = ((2.0d0 / (k ** 2.0d0)) * (l / t)) * t_1
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = (l / Math.sin(k)) / Math.tan(k);
double tmp;
if ((t <= -2.5e-36) || !(t <= 2.8e+144)) {
tmp = t_1 * (l / Math.pow(t, 3.0));
} else {
tmp = ((2.0 / Math.pow(k, 2.0)) * (l / t)) * t_1;
}
return tmp;
}
def code(t, l, k): t_1 = (l / math.sin(k)) / math.tan(k) tmp = 0 if (t <= -2.5e-36) or not (t <= 2.8e+144): tmp = t_1 * (l / math.pow(t, 3.0)) else: tmp = ((2.0 / math.pow(k, 2.0)) * (l / t)) * t_1 return tmp
function code(t, l, k) t_1 = Float64(Float64(l / sin(k)) / tan(k)) tmp = 0.0 if ((t <= -2.5e-36) || !(t <= 2.8e+144)) tmp = Float64(t_1 * Float64(l / (t ^ 3.0))); else tmp = Float64(Float64(Float64(2.0 / (k ^ 2.0)) * Float64(l / t)) * t_1); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (l / sin(k)) / tan(k); tmp = 0.0; if ((t <= -2.5e-36) || ~((t <= 2.8e+144))) tmp = t_1 * (l / (t ^ 3.0)); else tmp = ((2.0 / (k ^ 2.0)) * (l / t)) * t_1; end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t, -2.5e-36], N[Not[LessEqual[t, 2.8e+144]], $MachinePrecision]], N[(t$95$1 * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{if}\;t \leq -2.5 \cdot 10^{-36} \lor \neg \left(t \leq 2.8 \cdot 10^{+144}\right):\\
\;\;\;\;t_1 \cdot \frac{\ell}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{2}{{k}^{2}} \cdot \frac{\ell}{t}\right) \cdot t_1\\
\end{array}
\end{array}
if t < -2.50000000000000002e-36 or 2.80000000000000007e144 < t Initial program 61.6%
Simplified53.4%
associate-*r*61.7%
*-un-lft-identity61.7%
times-frac62.2%
Applied egg-rr62.2%
/-rgt-identity62.2%
associate-*r/61.7%
times-frac62.2%
*-commutative62.2%
associate-/r*68.2%
Simplified68.2%
Taylor expanded in t around inf 65.2%
if -2.50000000000000002e-36 < t < 2.80000000000000007e144Initial program 45.5%
Simplified42.9%
associate-*r*48.6%
*-un-lft-identity48.6%
times-frac49.3%
Applied egg-rr49.3%
/-rgt-identity49.3%
associate-*r/48.6%
times-frac50.0%
*-commutative50.0%
associate-/r*51.3%
Simplified51.3%
Taylor expanded in t around 0 76.5%
associate-*r/76.5%
times-frac78.7%
Simplified78.7%
Final simplification72.6%
(FPCore (t l k) :precision binary64 (if (<= k 7.2e+189) (* (/ (/ l (sin k)) (tan k)) (/ l (pow t 3.0))) (* 2.0 (/ (pow l 2.0) (* t (pow k 4.0))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 7.2e+189) {
tmp = ((l / sin(k)) / tan(k)) * (l / pow(t, 3.0));
} 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 (k <= 7.2d+189) then
tmp = ((l / sin(k)) / tan(k)) * (l / (t ** 3.0d0))
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 (k <= 7.2e+189) {
tmp = ((l / Math.sin(k)) / Math.tan(k)) * (l / Math.pow(t, 3.0));
} 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 k <= 7.2e+189: tmp = ((l / math.sin(k)) / math.tan(k)) * (l / math.pow(t, 3.0)) 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 (k <= 7.2e+189) tmp = Float64(Float64(Float64(l / sin(k)) / tan(k)) * Float64(l / (t ^ 3.0))); 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 (k <= 7.2e+189) tmp = ((l / sin(k)) / tan(k)) * (l / (t ^ 3.0)); else tmp = 2.0 * ((l ^ 2.0) / (t * (k ^ 4.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 7.2e+189], N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[t, 3.0], $MachinePrecision]), $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}\;k \leq 7.2 \cdot 10^{+189}:\\
\;\;\;\;\frac{\frac{\ell}{\sin k}}{\tan k} \cdot \frac{\ell}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2}}{t \cdot {k}^{4}}\\
\end{array}
\end{array}
if k < 7.20000000000000017e189Initial program 52.0%
Simplified46.2%
associate-*r*53.5%
*-un-lft-identity53.5%
times-frac54.2%
Applied egg-rr54.2%
/-rgt-identity54.2%
associate-*r/53.5%
times-frac54.6%
*-commutative54.6%
associate-/r*58.5%
Simplified58.5%
Taylor expanded in t around inf 59.0%
if 7.20000000000000017e189 < k Initial program 58.6%
Simplified58.6%
Taylor expanded in t around 0 72.7%
times-frac72.7%
Simplified72.7%
Taylor expanded in k around 0 72.7%
Final simplification60.6%
(FPCore (t l k) :precision binary64 (if (or (<= t -3.3e+220) (not (<= t 8.8e+136))) (/ (* (* l l) (/ 2.0 (pow t 3.0))) (* 2.0 (pow k 2.0))) (* 2.0 (/ 1.0 (/ (pow k 4.0) (/ (pow l 2.0) t))))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -3.3e+220) || !(t <= 8.8e+136)) {
tmp = ((l * l) * (2.0 / pow(t, 3.0))) / (2.0 * pow(k, 2.0));
} else {
tmp = 2.0 * (1.0 / (pow(k, 4.0) / (pow(l, 2.0) / t)));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((t <= (-3.3d+220)) .or. (.not. (t <= 8.8d+136))) then
tmp = ((l * l) * (2.0d0 / (t ** 3.0d0))) / (2.0d0 * (k ** 2.0d0))
else
tmp = 2.0d0 * (1.0d0 / ((k ** 4.0d0) / ((l ** 2.0d0) / t)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -3.3e+220) || !(t <= 8.8e+136)) {
tmp = ((l * l) * (2.0 / Math.pow(t, 3.0))) / (2.0 * Math.pow(k, 2.0));
} else {
tmp = 2.0 * (1.0 / (Math.pow(k, 4.0) / (Math.pow(l, 2.0) / t)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -3.3e+220) or not (t <= 8.8e+136): tmp = ((l * l) * (2.0 / math.pow(t, 3.0))) / (2.0 * math.pow(k, 2.0)) else: tmp = 2.0 * (1.0 / (math.pow(k, 4.0) / (math.pow(l, 2.0) / t))) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -3.3e+220) || !(t <= 8.8e+136)) tmp = Float64(Float64(Float64(l * l) * Float64(2.0 / (t ^ 3.0))) / Float64(2.0 * (k ^ 2.0))); else tmp = Float64(2.0 * Float64(1.0 / Float64((k ^ 4.0) / Float64((l ^ 2.0) / t)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -3.3e+220) || ~((t <= 8.8e+136))) tmp = ((l * l) * (2.0 / (t ^ 3.0))) / (2.0 * (k ^ 2.0)); else tmp = 2.0 * (1.0 / ((k ^ 4.0) / ((l ^ 2.0) / t))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -3.3e+220], N[Not[LessEqual[t, 8.8e+136]], $MachinePrecision]], N[(N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(1.0 / N[(N[Power[k, 4.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.3 \cdot 10^{+220} \lor \neg \left(t \leq 8.8 \cdot 10^{+136}\right):\\
\;\;\;\;\frac{\left(\ell \cdot \ell\right) \cdot \frac{2}{{t}^{3}}}{2 \cdot {k}^{2}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{1}{\frac{{k}^{4}}{\frac{{\ell}^{2}}{t}}}\\
\end{array}
\end{array}
if t < -3.30000000000000021e220 or 8.7999999999999998e136 < t Initial program 64.6%
Simplified53.0%
Taylor expanded in k around 0 53.0%
if -3.30000000000000021e220 < t < 8.7999999999999998e136Initial program 48.3%
Simplified45.6%
Taylor expanded in t around 0 64.6%
times-frac64.6%
Simplified64.6%
Taylor expanded in k around 0 53.0%
*-commutative53.0%
associate-/r*54.8%
Simplified54.8%
clear-num54.8%
inv-pow54.8%
Applied egg-rr54.8%
unpow-154.8%
Simplified54.8%
Final simplification54.3%
(FPCore (t l k) :precision binary64 (* 2.0 (/ 1.0 (/ (pow k 4.0) (/ (pow l 2.0) t)))))
double code(double t, double l, double k) {
return 2.0 * (1.0 / (pow(k, 4.0) / (pow(l, 2.0) / t)));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 * (1.0d0 / ((k ** 4.0d0) / ((l ** 2.0d0) / t)))
end function
public static double code(double t, double l, double k) {
return 2.0 * (1.0 / (Math.pow(k, 4.0) / (Math.pow(l, 2.0) / t)));
}
def code(t, l, k): return 2.0 * (1.0 / (math.pow(k, 4.0) / (math.pow(l, 2.0) / t)))
function code(t, l, k) return Float64(2.0 * Float64(1.0 / Float64((k ^ 4.0) / Float64((l ^ 2.0) / t)))) end
function tmp = code(t, l, k) tmp = 2.0 * (1.0 / ((k ^ 4.0) / ((l ^ 2.0) / t))); end
code[t_, l_, k_] := N[(2.0 * N[(1.0 / N[(N[Power[k, 4.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \frac{1}{\frac{{k}^{4}}{\frac{{\ell}^{2}}{t}}}
\end{array}
Initial program 52.7%
Simplified47.6%
Taylor expanded in t around 0 57.4%
times-frac58.2%
Simplified58.2%
Taylor expanded in k around 0 48.6%
*-commutative48.6%
associate-/r*49.9%
Simplified49.9%
clear-num49.9%
inv-pow49.9%
Applied egg-rr49.9%
unpow-149.9%
Simplified49.9%
Final simplification49.9%
(FPCore (t l k) :precision binary64 (* 2.0 (* (/ (pow l 2.0) t) (pow k -4.0))))
double code(double t, double l, double k) {
return 2.0 * ((pow(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 = 2.0d0 * (((l ** 2.0d0) / t) * (k ** (-4.0d0)))
end function
public static double code(double t, double l, double k) {
return 2.0 * ((Math.pow(l, 2.0) / t) * Math.pow(k, -4.0));
}
def code(t, l, k): return 2.0 * ((math.pow(l, 2.0) / t) * math.pow(k, -4.0))
function code(t, l, k) return Float64(2.0 * Float64(Float64((l ^ 2.0) / t) * (k ^ -4.0))) end
function tmp = code(t, l, k) tmp = 2.0 * (((l ^ 2.0) / t) * (k ^ -4.0)); end
code[t_, l_, k_] := N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / t), $MachinePrecision] * N[Power[k, -4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\frac{{\ell}^{2}}{t} \cdot {k}^{-4}\right)
\end{array}
Initial program 52.7%
Simplified47.6%
Taylor expanded in t around 0 57.4%
times-frac58.2%
Simplified58.2%
Taylor expanded in k around 0 48.6%
*-commutative48.6%
associate-/r*49.9%
Simplified49.9%
expm1-log1p-u37.6%
expm1-udef38.1%
div-inv38.1%
pow-flip38.1%
metadata-eval38.1%
Applied egg-rr38.1%
expm1-def37.6%
expm1-log1p49.9%
Simplified49.9%
Final simplification49.9%
herbie shell --seed 2023299
(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))))