
(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 11 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 (/ (* l (sqrt 2.0)) (pow t 1.5))) (t_2 (+ 2.0 (pow (/ k t) 2.0))))
(if (<= t -2.8e-76)
(/
(/ 2.0 (* (pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k))) 3.0) (tan k)))
t_2)
(if (<= t 2e-89)
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) (/ l (tan k)))
(* (/ t_1 (* (sin k) t_2)) (/ t_1 (tan k)))))))
double code(double t, double l, double k) {
double t_1 = (l * sqrt(2.0)) / pow(t, 1.5);
double t_2 = 2.0 + pow((k / t), 2.0);
double tmp;
if (t <= -2.8e-76) {
tmp = (2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))), 3.0) * tan(k))) / t_2;
} else if (t <= 2e-89) {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * (l / tan(k));
} else {
tmp = (t_1 / (sin(k) * t_2)) * (t_1 / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = (l * Math.sqrt(2.0)) / Math.pow(t, 1.5);
double t_2 = 2.0 + Math.pow((k / t), 2.0);
double tmp;
if (t <= -2.8e-76) {
tmp = (2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k))), 3.0) * Math.tan(k))) / t_2;
} else if (t <= 2e-89) {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * (l / Math.tan(k));
} else {
tmp = (t_1 / (Math.sin(k) * t_2)) * (t_1 / Math.tan(k));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(Float64(l * sqrt(2.0)) / (t ^ 1.5)) t_2 = Float64(2.0 + (Float64(k / t) ^ 2.0)) tmp = 0.0 if (t <= -2.8e-76) tmp = Float64(Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) ^ 3.0) * tan(k))) / t_2); elseif (t <= 2e-89) tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * Float64(l / tan(k))); else tmp = Float64(Float64(t_1 / Float64(sin(k) * t_2)) * Float64(t_1 / tan(k))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[Power[t, 1.5], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.8e-76], 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] / t$95$2), $MachinePrecision], If[LessEqual[t, 2e-89], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$1 / N[(N[Sin[k], $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\ell \cdot \sqrt{2}}{{t}^{1.5}}\\
t_2 := 2 + {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;t \leq -2.8 \cdot 10^{-76}:\\
\;\;\;\;\frac{\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right)}^{3} \cdot \tan k}}{t_2}\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-89}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot \frac{\ell}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\frac{t_1}{\sin k \cdot t_2} \cdot \frac{t_1}{\tan k}\\
\end{array}
\end{array}
if t < -2.8000000000000001e-76Initial program 65.1%
Simplified72.5%
add-cube-cbrt72.6%
pow372.6%
cbrt-div72.4%
rem-cbrt-cube78.5%
Applied egg-rr78.5%
add-cube-cbrt78.4%
pow278.4%
cbrt-div78.4%
unpow378.4%
add-cbrt-cube78.4%
cbrt-div78.4%
unpow378.4%
add-cbrt-cube88.7%
Applied egg-rr88.7%
add-cube-cbrt88.5%
pow388.5%
cbrt-prod88.5%
unpow288.5%
add-cbrt-cube95.6%
associate-/l/95.7%
pow295.7%
Applied egg-rr95.7%
if -2.8000000000000001e-76 < t < 2.00000000000000008e-89Initial program 41.6%
Simplified41.3%
associate-*r*47.2%
associate-*r*47.2%
times-frac48.4%
div-inv48.4%
pow-flip48.4%
metadata-eval48.4%
Applied egg-rr48.4%
Taylor expanded in t around 0 85.3%
if 2.00000000000000008e-89 < t Initial program 65.0%
Simplified55.9%
add-sqr-sqrt55.9%
associate-*r*55.9%
times-frac64.9%
*-commutative64.9%
sqrt-prod65.0%
sqrt-prod30.8%
add-sqr-sqrt53.2%
sqrt-div53.2%
sqrt-pow153.2%
metadata-eval53.2%
Applied egg-rr88.1%
associate-*r/88.1%
*-commutative88.1%
associate-*r/88.1%
Simplified88.1%
Final simplification89.5%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ l (tan k))) (t_2 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(+ 1.0 (+ t_2 1.0))
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))))
5e+287)
(* t_1 (* (/ (* 2.0 (pow t -3.0)) (+ 2.0 t_2)) (/ l (sin k))))
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) t_1))))
double code(double t, double l, double k) {
double t_1 = l / tan(k);
double t_2 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_2 + 1.0)) * (tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))))) <= 5e+287) {
tmp = t_1 * (((2.0 * pow(t, -3.0)) / (2.0 + t_2)) * (l / sin(k)));
} else {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * t_1;
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = l / tan(k)
t_2 = (k / t) ** 2.0d0
if ((2.0d0 / ((1.0d0 + (t_2 + 1.0d0)) * (tan(k) * (sin(k) * ((t ** 3.0d0) / (l * l)))))) <= 5d+287) then
tmp = t_1 * (((2.0d0 * (t ** (-3.0d0))) / (2.0d0 + t_2)) * (l / sin(k)))
else
tmp = (2.0d0 * (l / ((k ** 2.0d0) * (t * sin(k))))) * t_1
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = l / Math.tan(k);
double t_2 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_2 + 1.0)) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))))) <= 5e+287) {
tmp = t_1 * (((2.0 * Math.pow(t, -3.0)) / (2.0 + t_2)) * (l / Math.sin(k)));
} else {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * t_1;
}
return tmp;
}
def code(t, l, k): t_1 = l / math.tan(k) t_2 = math.pow((k / t), 2.0) tmp = 0 if (2.0 / ((1.0 + (t_2 + 1.0)) * (math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))))) <= 5e+287: tmp = t_1 * (((2.0 * math.pow(t, -3.0)) / (2.0 + t_2)) * (l / math.sin(k))) else: tmp = (2.0 * (l / (math.pow(k, 2.0) * (t * math.sin(k))))) * t_1 return tmp
function code(t, l, k) t_1 = Float64(l / tan(k)) t_2 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(1.0 + Float64(t_2 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))))) <= 5e+287) tmp = Float64(t_1 * Float64(Float64(Float64(2.0 * (t ^ -3.0)) / Float64(2.0 + t_2)) * Float64(l / sin(k)))); else tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * t_1); end return tmp end
function tmp_2 = code(t, l, k) t_1 = l / tan(k); t_2 = (k / t) ^ 2.0; tmp = 0.0; if ((2.0 / ((1.0 + (t_2 + 1.0)) * (tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))))) <= 5e+287) tmp = t_1 * (((2.0 * (t ^ -3.0)) / (2.0 + t_2)) * (l / sin(k))); else tmp = (2.0 * (l / ((k ^ 2.0) * (t * sin(k))))) * t_1; end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(1.0 + N[(t$95$2 + 1.0), $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+287], N[(t$95$1 * N[(N[(N[(2.0 * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision] / N[(2.0 + t$95$2), $MachinePrecision]), $MachinePrecision] * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k}\\
t_2 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(1 + \left(t_2 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq 5 \cdot 10^{+287}:\\
\;\;\;\;t_1 \cdot \left(\frac{2 \cdot {t}^{-3}}{2 + t_2} \cdot \frac{\ell}{\sin k}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot t_1\\
\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))) < 5e287Initial program 79.6%
Simplified68.9%
associate-*r*70.8%
associate-*r*70.8%
times-frac86.2%
div-inv86.2%
pow-flip86.6%
metadata-eval86.6%
Applied egg-rr86.6%
times-frac89.2%
Simplified89.2%
if 5e287 < (/.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.0%
Simplified23.8%
associate-*r*33.7%
associate-*r*33.7%
times-frac33.9%
div-inv33.9%
pow-flip33.9%
metadata-eval33.9%
Applied egg-rr33.9%
Taylor expanded in t around 0 64.9%
Final simplification79.6%
(FPCore (t l k)
:precision binary64
(if (or (<= t -6e-73) (not (<= t 4.4e-85)))
(/
(/ 2.0 (* (pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k))) 3.0) (tan k)))
(+ 2.0 (pow (/ k t) 2.0)))
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) (/ l (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -6e-73) || !(t <= 4.4e-85)) {
tmp = (2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))), 3.0) * tan(k))) / (2.0 + pow((k / t), 2.0));
} else {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * (l / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -6e-73) || !(t <= 4.4e-85)) {
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 + Math.pow((k / t), 2.0));
} else {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * (l / Math.tan(k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -6e-73) || !(t <= 4.4e-85)) tmp = Float64(Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) ^ 3.0) * tan(k))) / Float64(2.0 + (Float64(k / t) ^ 2.0))); else tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * Float64(l / tan(k))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -6e-73], N[Not[LessEqual[t, 4.4e-85]], $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[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -6 \cdot 10^{-73} \lor \neg \left(t \leq 4.4 \cdot 10^{-85}\right):\\
\;\;\;\;\frac{\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right)}^{3} \cdot \tan k}}{2 + {\left(\frac{k}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot \frac{\ell}{\tan k}\\
\end{array}
\end{array}
if t < -6e-73 or 4.4e-85 < t Initial program 65.0%
Simplified70.7%
add-cube-cbrt70.6%
pow370.6%
cbrt-div70.6%
rem-cbrt-cube75.1%
Applied egg-rr75.1%
add-cube-cbrt75.0%
pow275.0%
cbrt-div75.0%
unpow375.0%
add-cbrt-cube75.0%
cbrt-div74.9%
unpow374.9%
add-cbrt-cube83.7%
Applied egg-rr83.7%
add-cube-cbrt83.6%
pow383.6%
cbrt-prod83.6%
unpow283.6%
add-cbrt-cube90.2%
associate-/l/90.2%
pow290.2%
Applied egg-rr90.2%
if -6e-73 < t < 4.4e-85Initial program 41.6%
Simplified41.3%
associate-*r*47.2%
associate-*r*47.2%
times-frac48.4%
div-inv48.4%
pow-flip48.4%
metadata-eval48.4%
Applied egg-rr48.4%
Taylor expanded in t around 0 85.3%
Final simplification88.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (+ 2.0 (pow (/ k t) 2.0)))
(t_2 (/ t (cbrt l)))
(t_3 (/ l (tan k)))
(t_4 (* (/ (* 2.0 (pow t -3.0)) t_1) (/ l (sin k)))))
(if (<= t -6.8e+117)
(/ (/ 2.0 (* (tan k) (* (sin k) (pow (/ t (pow (cbrt l) 2.0)) 3.0)))) t_1)
(if (<= t -2.3e-76)
(/ (* l t_4) (tan k))
(if (<= t 8.6e-86)
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) t_3)
(if (<= t 1.2e+105)
(* t_3 t_4)
(/
(/ 2.0 (* (tan k) (* (sin k) (* t_2 (/ (pow t_2 2.0) l)))))
t_1)))))))
double code(double t, double l, double k) {
double t_1 = 2.0 + pow((k / t), 2.0);
double t_2 = t / cbrt(l);
double t_3 = l / tan(k);
double t_4 = ((2.0 * pow(t, -3.0)) / t_1) * (l / sin(k));
double tmp;
if (t <= -6.8e+117) {
tmp = (2.0 / (tan(k) * (sin(k) * pow((t / pow(cbrt(l), 2.0)), 3.0)))) / t_1;
} else if (t <= -2.3e-76) {
tmp = (l * t_4) / tan(k);
} else if (t <= 8.6e-86) {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * t_3;
} else if (t <= 1.2e+105) {
tmp = t_3 * t_4;
} else {
tmp = (2.0 / (tan(k) * (sin(k) * (t_2 * (pow(t_2, 2.0) / l))))) / t_1;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = 2.0 + Math.pow((k / t), 2.0);
double t_2 = t / Math.cbrt(l);
double t_3 = l / Math.tan(k);
double t_4 = ((2.0 * Math.pow(t, -3.0)) / t_1) * (l / Math.sin(k));
double tmp;
if (t <= -6.8e+117) {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)))) / t_1;
} else if (t <= -2.3e-76) {
tmp = (l * t_4) / Math.tan(k);
} else if (t <= 8.6e-86) {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * t_3;
} else if (t <= 1.2e+105) {
tmp = t_3 * t_4;
} else {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * (t_2 * (Math.pow(t_2, 2.0) / l))))) / t_1;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(2.0 + (Float64(k / t) ^ 2.0)) t_2 = Float64(t / cbrt(l)) t_3 = Float64(l / tan(k)) t_4 = Float64(Float64(Float64(2.0 * (t ^ -3.0)) / t_1) * Float64(l / sin(k))) tmp = 0.0 if (t <= -6.8e+117) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))) / t_1); elseif (t <= -2.3e-76) tmp = Float64(Float64(l * t_4) / tan(k)); elseif (t <= 8.6e-86) tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * t_3); elseif (t <= 1.2e+105) tmp = Float64(t_3 * t_4); else tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * Float64(t_2 * Float64((t_2 ^ 2.0) / l))))) / t_1); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(2.0 * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.8e+117], 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] / t$95$1), $MachinePrecision], If[LessEqual[t, -2.3e-76], N[(N[(l * t$95$4), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.6e-86], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$3), $MachinePrecision], If[LessEqual[t, 1.2e+105], N[(t$95$3 * t$95$4), $MachinePrecision], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(t$95$2 * N[(N[Power[t$95$2, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 + {\left(\frac{k}{t}\right)}^{2}\\
t_2 := \frac{t}{\sqrt[3]{\ell}}\\
t_3 := \frac{\ell}{\tan k}\\
t_4 := \frac{2 \cdot {t}^{-3}}{t_1} \cdot \frac{\ell}{\sin k}\\
\mathbf{if}\;t \leq -6.8 \cdot 10^{+117}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}}{t_1}\\
\mathbf{elif}\;t \leq -2.3 \cdot 10^{-76}:\\
\;\;\;\;\frac{\ell \cdot t_4}{\tan k}\\
\mathbf{elif}\;t \leq 8.6 \cdot 10^{-86}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot t_3\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{+105}:\\
\;\;\;\;t_3 \cdot t_4\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot \left(t_2 \cdot \frac{{t_2}^{2}}{\ell}\right)\right)}}{t_1}\\
\end{array}
\end{array}
if t < -6.8000000000000002e117Initial program 61.6%
Simplified66.5%
add-cube-cbrt66.5%
pow366.5%
cbrt-div66.5%
rem-cbrt-cube77.3%
Applied egg-rr77.3%
add-cube-cbrt77.3%
pow277.3%
cbrt-div77.3%
unpow377.3%
add-cbrt-cube77.3%
cbrt-div77.3%
unpow377.3%
add-cbrt-cube95.8%
Applied egg-rr95.8%
expm1-log1p-u59.3%
expm1-udef44.0%
pow-plus44.0%
associate-/l/44.0%
pow244.0%
metadata-eval44.0%
Applied egg-rr44.0%
expm1-def59.3%
expm1-log1p95.8%
*-commutative95.8%
Simplified95.8%
if -6.8000000000000002e117 < t < -2.30000000000000006e-76Initial program 69.4%
Simplified66.5%
associate-*r*74.6%
associate-*r*74.6%
times-frac88.6%
div-inv88.6%
pow-flip88.7%
metadata-eval88.7%
Applied egg-rr88.7%
associate-*r/88.7%
times-frac91.5%
Applied egg-rr91.5%
if -2.30000000000000006e-76 < t < 8.60000000000000026e-86Initial program 41.6%
Simplified41.3%
associate-*r*47.2%
associate-*r*47.2%
times-frac48.4%
div-inv48.4%
pow-flip48.4%
metadata-eval48.4%
Applied egg-rr48.4%
Taylor expanded in t around 0 85.3%
if 8.60000000000000026e-86 < t < 1.19999999999999987e105Initial program 71.6%
Simplified69.2%
associate-*r*71.6%
associate-*r*71.6%
times-frac81.9%
div-inv81.9%
pow-flip83.0%
metadata-eval83.0%
Applied egg-rr83.0%
times-frac87.7%
Simplified87.7%
if 1.19999999999999987e105 < t Initial program 57.7%
Simplified62.1%
add-cube-cbrt62.1%
pow362.1%
cbrt-div62.1%
rem-cbrt-cube68.4%
Applied egg-rr68.4%
unpow368.5%
unpow268.5%
associate-*r/84.3%
associate-/l/73.6%
Applied egg-rr73.6%
*-commutative73.6%
associate-*l/63.7%
*-commutative63.7%
times-frac84.3%
Simplified84.3%
Final simplification88.2%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (+ 2.0 (pow (/ k t) 2.0)))
(t_2
(/
(/ 2.0 (* (tan k) (* (sin k) (pow (/ t (pow (cbrt l) 2.0)) 3.0))))
t_1))
(t_3 (/ l (tan k)))
(t_4 (* (/ (* 2.0 (pow t -3.0)) t_1) (/ l (sin k)))))
(if (<= t -6.8e+117)
t_2
(if (<= t -3.2e-76)
(/ (* l t_4) (tan k))
(if (<= t 8e-89)
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) t_3)
(if (<= t 1.75e+105) (* t_3 t_4) t_2))))))
double code(double t, double l, double k) {
double t_1 = 2.0 + pow((k / t), 2.0);
double t_2 = (2.0 / (tan(k) * (sin(k) * pow((t / pow(cbrt(l), 2.0)), 3.0)))) / t_1;
double t_3 = l / tan(k);
double t_4 = ((2.0 * pow(t, -3.0)) / t_1) * (l / sin(k));
double tmp;
if (t <= -6.8e+117) {
tmp = t_2;
} else if (t <= -3.2e-76) {
tmp = (l * t_4) / tan(k);
} else if (t <= 8e-89) {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * t_3;
} else if (t <= 1.75e+105) {
tmp = t_3 * t_4;
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = 2.0 + Math.pow((k / t), 2.0);
double t_2 = (2.0 / (Math.tan(k) * (Math.sin(k) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)))) / t_1;
double t_3 = l / Math.tan(k);
double t_4 = ((2.0 * Math.pow(t, -3.0)) / t_1) * (l / Math.sin(k));
double tmp;
if (t <= -6.8e+117) {
tmp = t_2;
} else if (t <= -3.2e-76) {
tmp = (l * t_4) / Math.tan(k);
} else if (t <= 8e-89) {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * t_3;
} else if (t <= 1.75e+105) {
tmp = t_3 * t_4;
} else {
tmp = t_2;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(2.0 + (Float64(k / t) ^ 2.0)) t_2 = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)))) / t_1) t_3 = Float64(l / tan(k)) t_4 = Float64(Float64(Float64(2.0 * (t ^ -3.0)) / t_1) * Float64(l / sin(k))) tmp = 0.0 if (t <= -6.8e+117) tmp = t_2; elseif (t <= -3.2e-76) tmp = Float64(Float64(l * t_4) / tan(k)); elseif (t <= 8e-89) tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * t_3); elseif (t <= 1.75e+105) tmp = Float64(t_3 * t_4); else tmp = t_2; end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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] / t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(2.0 * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.8e+117], t$95$2, If[LessEqual[t, -3.2e-76], N[(N[(l * t$95$4), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-89], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$3), $MachinePrecision], If[LessEqual[t, 1.75e+105], N[(t$95$3 * t$95$4), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 + {\left(\frac{k}{t}\right)}^{2}\\
t_2 := \frac{\frac{2}{\tan k \cdot \left(\sin k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right)}}{t_1}\\
t_3 := \frac{\ell}{\tan k}\\
t_4 := \frac{2 \cdot {t}^{-3}}{t_1} \cdot \frac{\ell}{\sin k}\\
\mathbf{if}\;t \leq -6.8 \cdot 10^{+117}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -3.2 \cdot 10^{-76}:\\
\;\;\;\;\frac{\ell \cdot t_4}{\tan k}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-89}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot t_3\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{+105}:\\
\;\;\;\;t_3 \cdot t_4\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -6.8000000000000002e117 or 1.74999999999999996e105 < t Initial program 59.6%
Simplified64.3%
add-cube-cbrt64.3%
pow364.3%
cbrt-div64.3%
rem-cbrt-cube72.9%
Applied egg-rr72.9%
add-cube-cbrt72.9%
pow272.9%
cbrt-div72.9%
unpow372.9%
add-cbrt-cube72.9%
cbrt-div72.8%
unpow372.8%
add-cbrt-cube89.9%
Applied egg-rr89.9%
expm1-log1p-u48.7%
expm1-udef37.8%
pow-plus37.8%
associate-/l/37.8%
pow237.8%
metadata-eval37.8%
Applied egg-rr37.8%
expm1-def48.7%
expm1-log1p90.0%
*-commutative90.0%
Simplified90.0%
if -6.8000000000000002e117 < t < -3.1999999999999998e-76Initial program 69.4%
Simplified66.5%
associate-*r*74.6%
associate-*r*74.6%
times-frac88.6%
div-inv88.6%
pow-flip88.7%
metadata-eval88.7%
Applied egg-rr88.7%
associate-*r/88.7%
times-frac91.5%
Applied egg-rr91.5%
if -3.1999999999999998e-76 < t < 8.00000000000000031e-89Initial program 41.6%
Simplified41.3%
associate-*r*47.2%
associate-*r*47.2%
times-frac48.4%
div-inv48.4%
pow-flip48.4%
metadata-eval48.4%
Applied egg-rr48.4%
Taylor expanded in t around 0 85.3%
if 8.00000000000000031e-89 < t < 1.74999999999999996e105Initial program 71.6%
Simplified69.2%
associate-*r*71.6%
associate-*r*71.6%
times-frac81.9%
div-inv81.9%
pow-flip83.0%
metadata-eval83.0%
Applied egg-rr83.0%
times-frac87.7%
Simplified87.7%
Final simplification88.2%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0))
(t_2 (+ 2.0 t_1))
(t_3 (/ l (tan k)))
(t_4 (* (/ (* 2.0 (pow t -3.0)) t_2) (/ l (sin k)))))
(if (<= t -6.8e+117)
(/ (/ 2.0 (* (tan k) (* (sin k) (/ (pow (/ t (cbrt l)) 3.0) l)))) t_2)
(if (<= t -3.3e-74)
(/ (* l t_4) (tan k))
(if (<= t 4e-86)
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) t_3)
(if (<= t 2.15e+105)
(* t_3 t_4)
(/
2.0
(*
(* (tan k) (* (sin k) (pow (/ (pow t 1.5) l) 2.0)))
(+ 1.0 (+ t_1 1.0))))))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double t_2 = 2.0 + t_1;
double t_3 = l / tan(k);
double t_4 = ((2.0 * pow(t, -3.0)) / t_2) * (l / sin(k));
double tmp;
if (t <= -6.8e+117) {
tmp = (2.0 / (tan(k) * (sin(k) * (pow((t / cbrt(l)), 3.0) / l)))) / t_2;
} else if (t <= -3.3e-74) {
tmp = (l * t_4) / tan(k);
} else if (t <= 4e-86) {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * t_3;
} else if (t <= 2.15e+105) {
tmp = t_3 * t_4;
} else {
tmp = 2.0 / ((tan(k) * (sin(k) * pow((pow(t, 1.5) / l), 2.0))) * (1.0 + (t_1 + 1.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double t_2 = 2.0 + t_1;
double t_3 = l / Math.tan(k);
double t_4 = ((2.0 * Math.pow(t, -3.0)) / t_2) * (l / Math.sin(k));
double tmp;
if (t <= -6.8e+117) {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * (Math.pow((t / Math.cbrt(l)), 3.0) / l)))) / t_2;
} else if (t <= -3.3e-74) {
tmp = (l * t_4) / Math.tan(k);
} else if (t <= 4e-86) {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * t_3;
} else if (t <= 2.15e+105) {
tmp = t_3 * t_4;
} else {
tmp = 2.0 / ((Math.tan(k) * (Math.sin(k) * Math.pow((Math.pow(t, 1.5) / l), 2.0))) * (1.0 + (t_1 + 1.0)));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 t_2 = Float64(2.0 + t_1) t_3 = Float64(l / tan(k)) t_4 = Float64(Float64(Float64(2.0 * (t ^ -3.0)) / t_2) * Float64(l / sin(k))) tmp = 0.0 if (t <= -6.8e+117) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * Float64((Float64(t / cbrt(l)) ^ 3.0) / l)))) / t_2); elseif (t <= -3.3e-74) tmp = Float64(Float64(l * t_4) / tan(k)); elseif (t <= 4e-86) tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * t_3); elseif (t <= 2.15e+105) tmp = Float64(t_3 * t_4); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * (Float64((t ^ 1.5) / l) ^ 2.0))) * Float64(1.0 + Float64(t_1 + 1.0)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$2 = N[(2.0 + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(2.0 * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] * N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.8e+117], 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$2), $MachinePrecision], If[LessEqual[t, -3.3e-74], N[(N[(l * t$95$4), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4e-86], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$3), $MachinePrecision], If[LessEqual[t, 2.15e+105], N[(t$95$3 * t$95$4), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(N[Power[t, 1.5], $MachinePrecision] / l), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
t_2 := 2 + t_1\\
t_3 := \frac{\ell}{\tan k}\\
t_4 := \frac{2 \cdot {t}^{-3}}{t_2} \cdot \frac{\ell}{\sin k}\\
\mathbf{if}\;t \leq -6.8 \cdot 10^{+117}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot \frac{{\left(\frac{t}{\sqrt[3]{\ell}}\right)}^{3}}{\ell}\right)}}{t_2}\\
\mathbf{elif}\;t \leq -3.3 \cdot 10^{-74}:\\
\;\;\;\;\frac{\ell \cdot t_4}{\tan k}\\
\mathbf{elif}\;t \leq 4 \cdot 10^{-86}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot t_3\\
\mathbf{elif}\;t \leq 2.15 \cdot 10^{+105}:\\
\;\;\;\;t_3 \cdot t_4\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot {\left(\frac{{t}^{1.5}}{\ell}\right)}^{2}\right)\right) \cdot \left(1 + \left(t_1 + 1\right)\right)}\\
\end{array}
\end{array}
if t < -6.8000000000000002e117Initial program 61.6%
Simplified66.5%
add-cube-cbrt66.5%
pow366.5%
cbrt-div66.5%
rem-cbrt-cube77.3%
Applied egg-rr77.3%
if -6.8000000000000002e117 < t < -3.29999999999999996e-74Initial program 69.4%
Simplified66.5%
associate-*r*74.6%
associate-*r*74.6%
times-frac88.6%
div-inv88.6%
pow-flip88.7%
metadata-eval88.7%
Applied egg-rr88.7%
associate-*r/88.7%
times-frac91.5%
Applied egg-rr91.5%
if -3.29999999999999996e-74 < t < 4.00000000000000034e-86Initial program 41.6%
Simplified41.3%
associate-*r*47.2%
associate-*r*47.2%
times-frac48.4%
div-inv48.4%
pow-flip48.4%
metadata-eval48.4%
Applied egg-rr48.4%
Taylor expanded in t around 0 85.3%
if 4.00000000000000034e-86 < t < 2.1500000000000001e105Initial program 71.6%
Simplified69.2%
associate-*r*71.6%
associate-*r*71.6%
times-frac81.9%
div-inv81.9%
pow-flip83.0%
metadata-eval83.0%
Applied egg-rr83.0%
times-frac87.7%
Simplified87.7%
if 2.1500000000000001e105 < t Initial program 57.7%
add-sqr-sqrt57.7%
pow257.7%
sqrt-div57.7%
sqrt-pow166.7%
metadata-eval66.7%
sqrt-prod37.7%
add-sqr-sqrt81.6%
Applied egg-rr81.6%
Final simplification84.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ l (tan k))))
(if (<= t -1.75e+55)
(* t_1 (/ l (* (sin k) (pow t 3.0))))
(if (<= t 1.9e-86)
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) t_1)
(/
2.0
(pow
(* (* k (/ (pow t 1.5) l)) (hypot 1.0 (hypot 1.0 (/ k t))))
2.0))))))
double code(double t, double l, double k) {
double t_1 = l / tan(k);
double tmp;
if (t <= -1.75e+55) {
tmp = t_1 * (l / (sin(k) * pow(t, 3.0)));
} else if (t <= 1.9e-86) {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * t_1;
} else {
tmp = 2.0 / pow(((k * (pow(t, 1.5) / l)) * hypot(1.0, hypot(1.0, (k / t)))), 2.0);
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = l / Math.tan(k);
double tmp;
if (t <= -1.75e+55) {
tmp = t_1 * (l / (Math.sin(k) * Math.pow(t, 3.0)));
} else if (t <= 1.9e-86) {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * t_1;
} else {
tmp = 2.0 / Math.pow(((k * (Math.pow(t, 1.5) / l)) * Math.hypot(1.0, Math.hypot(1.0, (k / t)))), 2.0);
}
return tmp;
}
def code(t, l, k): t_1 = l / math.tan(k) tmp = 0 if t <= -1.75e+55: tmp = t_1 * (l / (math.sin(k) * math.pow(t, 3.0))) elif t <= 1.9e-86: tmp = (2.0 * (l / (math.pow(k, 2.0) * (t * math.sin(k))))) * t_1 else: tmp = 2.0 / math.pow(((k * (math.pow(t, 1.5) / l)) * math.hypot(1.0, math.hypot(1.0, (k / t)))), 2.0) return tmp
function code(t, l, k) t_1 = Float64(l / tan(k)) tmp = 0.0 if (t <= -1.75e+55) tmp = Float64(t_1 * Float64(l / Float64(sin(k) * (t ^ 3.0)))); elseif (t <= 1.9e-86) tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * t_1); else tmp = Float64(2.0 / (Float64(Float64(k * Float64((t ^ 1.5) / l)) * hypot(1.0, hypot(1.0, Float64(k / t)))) ^ 2.0)); end return tmp end
function tmp_2 = code(t, l, k) t_1 = l / tan(k); tmp = 0.0; if (t <= -1.75e+55) tmp = t_1 * (l / (sin(k) * (t ^ 3.0))); elseif (t <= 1.9e-86) tmp = (2.0 * (l / ((k ^ 2.0) * (t * sin(k))))) * t_1; else tmp = 2.0 / (((k * ((t ^ 1.5) / l)) * hypot(1.0, hypot(1.0, (k / t)))) ^ 2.0); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.75e+55], N[(t$95$1 * N[(l / N[(N[Sin[k], $MachinePrecision] * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.9e-86], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], N[(2.0 / N[Power[N[(N[(k * N[(N[Power[t, 1.5], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] * N[Sqrt[1.0 ^ 2 + N[Sqrt[1.0 ^ 2 + N[(k / t), $MachinePrecision] ^ 2], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k}\\
\mathbf{if}\;t \leq -1.75 \cdot 10^{+55}:\\
\;\;\;\;t_1 \cdot \frac{\ell}{\sin k \cdot {t}^{3}}\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{-86}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\left(k \cdot \frac{{t}^{1.5}}{\ell}\right) \cdot \mathsf{hypot}\left(1, \mathsf{hypot}\left(1, \frac{k}{t}\right)\right)\right)}^{2}}\\
\end{array}
\end{array}
if t < -1.75000000000000005e55Initial program 62.8%
Simplified51.3%
associate-*r*57.7%
associate-*r*57.7%
times-frac72.4%
div-inv72.4%
pow-flip72.5%
metadata-eval72.5%
Applied egg-rr72.5%
Taylor expanded in t around inf 74.0%
if -1.75000000000000005e55 < t < 1.9e-86Initial program 47.1%
Simplified46.8%
associate-*r*52.6%
associate-*r*52.6%
times-frac55.5%
div-inv55.5%
pow-flip55.5%
metadata-eval55.5%
Applied egg-rr55.5%
Taylor expanded in t around 0 83.2%
if 1.9e-86 < t Initial program 65.0%
add-sqr-sqrt50.8%
pow250.8%
Applied egg-rr53.7%
Taylor expanded in k around 0 76.5%
Final simplification78.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ l (tan k))))
(if (<= k 2.5e-28)
(* t_1 (/ (/ l k) (pow t 3.0)))
(* t_1 (* 2.0 (/ l (* (sin k) (* t (pow k 2.0)))))))))
double code(double t, double l, double k) {
double t_1 = l / tan(k);
double tmp;
if (k <= 2.5e-28) {
tmp = t_1 * ((l / k) / pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (sin(k) * (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 / tan(k)
if (k <= 2.5d-28) then
tmp = t_1 * ((l / k) / (t ** 3.0d0))
else
tmp = t_1 * (2.0d0 * (l / (sin(k) * (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.tan(k);
double tmp;
if (k <= 2.5e-28) {
tmp = t_1 * ((l / k) / Math.pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (Math.sin(k) * (t * Math.pow(k, 2.0)))));
}
return tmp;
}
def code(t, l, k): t_1 = l / math.tan(k) tmp = 0 if k <= 2.5e-28: tmp = t_1 * ((l / k) / math.pow(t, 3.0)) else: tmp = t_1 * (2.0 * (l / (math.sin(k) * (t * math.pow(k, 2.0))))) return tmp
function code(t, l, k) t_1 = Float64(l / tan(k)) tmp = 0.0 if (k <= 2.5e-28) tmp = Float64(t_1 * Float64(Float64(l / k) / (t ^ 3.0))); else tmp = Float64(t_1 * Float64(2.0 * Float64(l / Float64(sin(k) * Float64(t * (k ^ 2.0)))))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = l / tan(k); tmp = 0.0; if (k <= 2.5e-28) tmp = t_1 * ((l / k) / (t ^ 3.0)); else tmp = t_1 * (2.0 * (l / (sin(k) * (t * (k ^ 2.0))))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, 2.5e-28], N[(t$95$1 * N[(N[(l / k), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(2.0 * N[(l / N[(N[Sin[k], $MachinePrecision] * N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k}\\
\mathbf{if}\;k \leq 2.5 \cdot 10^{-28}:\\
\;\;\;\;t_1 \cdot \frac{\frac{\ell}{k}}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \left(2 \cdot \frac{\ell}{\sin k \cdot \left(t \cdot {k}^{2}\right)}\right)\\
\end{array}
\end{array}
if k < 2.5000000000000001e-28Initial program 60.0%
Simplified52.0%
associate-*r*57.0%
associate-*r*57.0%
times-frac68.8%
div-inv68.8%
pow-flip69.1%
metadata-eval69.1%
Applied egg-rr69.1%
Taylor expanded in k around 0 66.9%
associate-/r*68.2%
Simplified68.2%
if 2.5000000000000001e-28 < k Initial program 48.7%
Simplified48.5%
associate-*r*53.8%
associate-*r*53.8%
times-frac55.4%
div-inv55.4%
pow-flip55.4%
metadata-eval55.4%
Applied egg-rr55.4%
Taylor expanded in t around 0 70.7%
associate-*r*70.6%
Simplified70.6%
Final simplification68.8%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ l (tan k))))
(if (<= k 1.85e-28)
(* t_1 (/ (/ l k) (pow t 3.0)))
(* (* 2.0 (/ l (* (pow k 2.0) (* t (sin k))))) t_1))))
double code(double t, double l, double k) {
double t_1 = l / tan(k);
double tmp;
if (k <= 1.85e-28) {
tmp = t_1 * ((l / k) / pow(t, 3.0));
} else {
tmp = (2.0 * (l / (pow(k, 2.0) * (t * sin(k))))) * t_1;
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: t_1
real(8) :: tmp
t_1 = l / tan(k)
if (k <= 1.85d-28) then
tmp = t_1 * ((l / k) / (t ** 3.0d0))
else
tmp = (2.0d0 * (l / ((k ** 2.0d0) * (t * sin(k))))) * t_1
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = l / Math.tan(k);
double tmp;
if (k <= 1.85e-28) {
tmp = t_1 * ((l / k) / Math.pow(t, 3.0));
} else {
tmp = (2.0 * (l / (Math.pow(k, 2.0) * (t * Math.sin(k))))) * t_1;
}
return tmp;
}
def code(t, l, k): t_1 = l / math.tan(k) tmp = 0 if k <= 1.85e-28: tmp = t_1 * ((l / k) / math.pow(t, 3.0)) else: tmp = (2.0 * (l / (math.pow(k, 2.0) * (t * math.sin(k))))) * t_1 return tmp
function code(t, l, k) t_1 = Float64(l / tan(k)) tmp = 0.0 if (k <= 1.85e-28) tmp = Float64(t_1 * Float64(Float64(l / k) / (t ^ 3.0))); else tmp = Float64(Float64(2.0 * Float64(l / Float64((k ^ 2.0) * Float64(t * sin(k))))) * t_1); end return tmp end
function tmp_2 = code(t, l, k) t_1 = l / tan(k); tmp = 0.0; if (k <= 1.85e-28) tmp = t_1 * ((l / k) / (t ^ 3.0)); else tmp = (2.0 * (l / ((k ^ 2.0) * (t * sin(k))))) * t_1; end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, 1.85e-28], N[(t$95$1 * N[(N[(l / k), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(l / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k}\\
\mathbf{if}\;k \leq 1.85 \cdot 10^{-28}:\\
\;\;\;\;t_1 \cdot \frac{\frac{\ell}{k}}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{{k}^{2} \cdot \left(t \cdot \sin k\right)}\right) \cdot t_1\\
\end{array}
\end{array}
if k < 1.8500000000000001e-28Initial program 60.0%
Simplified52.0%
associate-*r*57.0%
associate-*r*57.0%
times-frac68.8%
div-inv68.8%
pow-flip69.1%
metadata-eval69.1%
Applied egg-rr69.1%
Taylor expanded in k around 0 66.9%
associate-/r*68.2%
Simplified68.2%
if 1.8500000000000001e-28 < k Initial program 48.7%
Simplified48.5%
associate-*r*53.8%
associate-*r*53.8%
times-frac55.4%
div-inv55.4%
pow-flip55.4%
metadata-eval55.4%
Applied egg-rr55.4%
Taylor expanded in t around 0 70.7%
Final simplification68.8%
(FPCore (t l k) :precision binary64 (* (/ l (tan k)) (/ l (* k (pow t 3.0)))))
double code(double t, double l, double k) {
return (l / tan(k)) * (l / (k * pow(t, 3.0)));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l / tan(k)) * (l / (k * (t ** 3.0d0)))
end function
public static double code(double t, double l, double k) {
return (l / Math.tan(k)) * (l / (k * Math.pow(t, 3.0)));
}
def code(t, l, k): return (l / math.tan(k)) * (l / (k * math.pow(t, 3.0)))
function code(t, l, k) return Float64(Float64(l / tan(k)) * Float64(l / Float64(k * (t ^ 3.0)))) end
function tmp = code(t, l, k) tmp = (l / tan(k)) * (l / (k * (t ^ 3.0))); end
code[t_, l_, k_] := N[(N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\ell}{\tan k} \cdot \frac{\ell}{k \cdot {t}^{3}}
\end{array}
Initial program 57.2%
Simplified51.1%
associate-*r*56.2%
associate-*r*56.2%
times-frac65.6%
div-inv65.6%
pow-flip65.8%
metadata-eval65.8%
Applied egg-rr65.8%
Taylor expanded in k around 0 61.2%
Final simplification61.2%
(FPCore (t l k) :precision binary64 (* (/ l (tan k)) (/ (/ l k) (pow t 3.0))))
double code(double t, double l, double k) {
return (l / tan(k)) * ((l / k) / pow(t, 3.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l / tan(k)) * ((l / k) / (t ** 3.0d0))
end function
public static double code(double t, double l, double k) {
return (l / Math.tan(k)) * ((l / k) / Math.pow(t, 3.0));
}
def code(t, l, k): return (l / math.tan(k)) * ((l / k) / math.pow(t, 3.0))
function code(t, l, k) return Float64(Float64(l / tan(k)) * Float64(Float64(l / k) / (t ^ 3.0))) end
function tmp = code(t, l, k) tmp = (l / tan(k)) * ((l / k) / (t ^ 3.0)); end
code[t_, l_, k_] := N[(N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\ell}{\tan k} \cdot \frac{\frac{\ell}{k}}{{t}^{3}}
\end{array}
Initial program 57.2%
Simplified51.1%
associate-*r*56.2%
associate-*r*56.2%
times-frac65.6%
div-inv65.6%
pow-flip65.8%
metadata-eval65.8%
Applied egg-rr65.8%
Taylor expanded in k around 0 61.2%
associate-/r*62.6%
Simplified62.6%
Final simplification62.6%
herbie shell --seed 2023308
(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))))