
(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 20 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)) (t_2 (cbrt (sin k))))
(if (<= t -8.8e+43)
(* l (* l (/ 2.0 (pow (* (cbrt (* (tan k) (+ 2.0 t_1))) (* t t_2)) 3.0))))
(if (<= t 8e-49)
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k))))
(/
2.0
(*
(pow (* t_2 (* t (cbrt (pow l -2.0)))) 3.0)
(* (tan k) (+ 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 = cbrt(sin(k));
double tmp;
if (t <= -8.8e+43) {
tmp = l * (l * (2.0 / pow((cbrt((tan(k) * (2.0 + t_1))) * (t * t_2)), 3.0)));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
} else {
tmp = 2.0 / (pow((t_2 * (t * cbrt(pow(l, -2.0)))), 3.0) * (tan(k) * (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 = Math.cbrt(Math.sin(k));
double tmp;
if (t <= -8.8e+43) {
tmp = l * (l * (2.0 / Math.pow((Math.cbrt((Math.tan(k) * (2.0 + t_1))) * (t * t_2)), 3.0)));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
} else {
tmp = 2.0 / (Math.pow((t_2 * (t * Math.cbrt(Math.pow(l, -2.0)))), 3.0) * (Math.tan(k) * (1.0 + (t_1 + 1.0))));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 t_2 = cbrt(sin(k)) tmp = 0.0 if (t <= -8.8e+43) tmp = Float64(l * Float64(l * Float64(2.0 / (Float64(cbrt(Float64(tan(k) * Float64(2.0 + t_1))) * Float64(t * t_2)) ^ 3.0)))); elseif (t <= 8e-49) tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); else tmp = Float64(2.0 / Float64((Float64(t_2 * Float64(t * cbrt((l ^ -2.0)))) ^ 3.0) * Float64(tan(k) * 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[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]}, If[LessEqual[t, -8.8e+43], N[(l * N[(l * N[(2.0 / N[Power[N[(N[Power[N[(N[Tan[k], $MachinePrecision] * N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * N[(t * t$95$2), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-49], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(t$95$2 * N[(t * N[Power[N[Power[l, -2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
t_2 := \sqrt[3]{\sin k}\\
\mathbf{if}\;t \leq -8.8 \cdot 10^{+43}:\\
\;\;\;\;\ell \cdot \left(\ell \cdot \frac{2}{{\left(\sqrt[3]{\tan k \cdot \left(2 + t_1\right)} \cdot \left(t \cdot t_2\right)\right)}^{3}}\right)\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t_2 \cdot \left(t \cdot \sqrt[3]{{\ell}^{-2}}\right)\right)}^{3} \cdot \left(\tan k \cdot \left(1 + \left(t_1 + 1\right)\right)\right)}\\
\end{array}
\end{array}
if t < -8.80000000000000002e43Initial program 58.4%
associate-/l/58.4%
associate-*l/58.4%
associate-*l/59.8%
associate-/r/59.6%
*-commutative59.6%
associate-/l/59.6%
associate-*r*59.6%
*-commutative59.6%
associate-*r*59.6%
*-commutative59.6%
Simplified59.6%
add-cube-cbrt59.5%
pow359.5%
Applied egg-rr80.8%
pow180.8%
associate-*l*83.9%
Applied egg-rr83.9%
if -8.80000000000000002e43 < t < 7.99999999999999949e-49Initial program 46.0%
*-commutative46.0%
associate-*l*45.3%
associate-*r*45.2%
+-commutative45.2%
associate-+r+45.2%
metadata-eval45.2%
Simplified45.2%
add-cube-cbrt45.2%
pow345.2%
div-inv44.4%
cbrt-prod44.4%
unpow344.4%
add-cbrt-cube51.4%
pow251.4%
pow-flip51.5%
metadata-eval51.5%
Applied egg-rr51.5%
Taylor expanded in k around inf 71.6%
*-commutative71.6%
unpow271.6%
times-frac81.8%
unpow281.8%
Simplified81.8%
Taylor expanded in t around 0 71.6%
*-commutative71.6%
unpow271.6%
unpow271.6%
associate-*r*75.1%
times-frac94.3%
Simplified94.3%
if 7.99999999999999949e-49 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
add-cube-cbrt76.6%
pow376.6%
cbrt-prod76.5%
div-inv76.5%
cbrt-prod77.7%
unpow377.7%
add-cbrt-cube84.3%
pow284.3%
pow-flip84.3%
metadata-eval84.3%
Applied egg-rr84.3%
Final simplification89.1%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(+ 1.0 (+ t_1 1.0))
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))))
4e+218)
(*
l
(/ l (/ (* (* (tan k) (+ 2.0 t_1)) (pow (* t (cbrt (sin k))) 3.0)) 2.0)))
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))))) <= 4e+218) {
tmp = l * (l / (((tan(k) * (2.0 + t_1)) * pow((t * cbrt(sin(k))), 3.0)) / 2.0));
} else {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))))) <= 4e+218) {
tmp = l * (l / (((Math.tan(k) * (2.0 + t_1)) * Math.pow((t * Math.cbrt(Math.sin(k))), 3.0)) / 2.0));
} else {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(1.0 + Float64(t_1 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))))) <= 4e+218) tmp = Float64(l * Float64(l / Float64(Float64(Float64(tan(k) * Float64(2.0 + t_1)) * (Float64(t * cbrt(sin(k))) ^ 3.0)) / 2.0))); else tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(1.0 + N[(t$95$1 + 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], 4e+218], N[(l * N[(l / N[(N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision] * N[Power[N[(t * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(1 + \left(t_1 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq 4 \cdot 10^{+218}:\\
\;\;\;\;\ell \cdot \frac{\ell}{\frac{\left(\tan k \cdot \left(2 + t_1\right)\right) \cdot {\left(t \cdot \sqrt[3]{\sin k}\right)}^{3}}{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\end{array}
\end{array}
if (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) < 4.00000000000000033e218Initial program 82.3%
associate-/l/82.3%
associate-*l/82.9%
associate-*l/80.9%
associate-/r/80.9%
*-commutative80.9%
associate-/l/80.8%
associate-*r*81.4%
*-commutative81.4%
associate-*r*81.5%
*-commutative81.5%
Simplified81.5%
add-cube-cbrt81.3%
pow381.3%
Applied egg-rr86.3%
pow186.3%
associate-*l*89.2%
Applied egg-rr89.2%
associate-*r/89.9%
Applied egg-rr89.9%
associate-/l*89.9%
*-commutative89.9%
cube-prod88.0%
rem-cube-cbrt88.0%
*-commutative88.0%
Simplified88.0%
if 4.00000000000000033e218 < (/.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 24.2%
*-commutative24.2%
associate-*l*23.3%
associate-*r*23.3%
+-commutative23.3%
associate-+r+23.3%
metadata-eval23.3%
Simplified23.3%
add-cube-cbrt23.3%
pow323.3%
div-inv22.4%
cbrt-prod22.4%
unpow322.4%
add-cbrt-cube37.5%
pow237.5%
pow-flip37.7%
metadata-eval37.7%
Applied egg-rr37.7%
Taylor expanded in k around inf 59.8%
*-commutative59.8%
unpow259.8%
times-frac68.3%
unpow268.3%
Simplified68.3%
Taylor expanded in t around 0 59.8%
*-commutative59.8%
unpow259.8%
unpow259.8%
associate-*r*63.8%
times-frac83.7%
Simplified83.7%
Final simplification86.2%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (+ 1.0 (+ (pow (/ k t) 2.0) 1.0))))
(if (<=
(/ 2.0 (* t_1 (* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))))
1e+244)
(/ 2.0 (* (* (tan k) t_1) (* (/ (pow t 3.0) l) (/ (sin k) l))))
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k)))))))
double code(double t, double l, double k) {
double t_1 = 1.0 + (pow((k / t), 2.0) + 1.0);
double tmp;
if ((2.0 / (t_1 * (tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))))) <= 1e+244) {
tmp = 2.0 / ((tan(k) * t_1) * ((pow(t, 3.0) / l) * (sin(k) / l)));
} else {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(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) :: t_1
real(8) :: tmp
t_1 = 1.0d0 + (((k / t) ** 2.0d0) + 1.0d0)
if ((2.0d0 / (t_1 * (tan(k) * (sin(k) * ((t ** 3.0d0) / (l * l)))))) <= 1d+244) then
tmp = 2.0d0 / ((tan(k) * t_1) * (((t ** 3.0d0) / l) * (sin(k) / l)))
else
tmp = 2.0d0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = 1.0 + (Math.pow((k / t), 2.0) + 1.0);
double tmp;
if ((2.0 / (t_1 * (Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))))) <= 1e+244) {
tmp = 2.0 / ((Math.tan(k) * t_1) * ((Math.pow(t, 3.0) / l) * (Math.sin(k) / l)));
} else {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
}
return tmp;
}
def code(t, l, k): t_1 = 1.0 + (math.pow((k / t), 2.0) + 1.0) tmp = 0 if (2.0 / (t_1 * (math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))))) <= 1e+244: tmp = 2.0 / ((math.tan(k) * t_1) * ((math.pow(t, 3.0) / l) * (math.sin(k) / l))) else: tmp = 2.0 / ((((t * k) / l) * (k / l)) * (math.tan(k) * math.sin(k))) return tmp
function code(t, l, k) t_1 = Float64(1.0 + Float64((Float64(k / t) ^ 2.0) + 1.0)) tmp = 0.0 if (Float64(2.0 / Float64(t_1 * Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))))) <= 1e+244) tmp = Float64(2.0 / Float64(Float64(tan(k) * t_1) * Float64(Float64((t ^ 3.0) / l) * Float64(sin(k) / l)))); else tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = 1.0 + (((k / t) ^ 2.0) + 1.0); tmp = 0.0; if ((2.0 / (t_1 * (tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))))) <= 1e+244) tmp = 2.0 / ((tan(k) * t_1) * (((t ^ 3.0) / l) * (sin(k) / l))); else tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(1.0 + N[(N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(t$95$1 * 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], 1e+244], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * t$95$1), $MachinePrecision] * N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 1 + \left({\left(\frac{k}{t}\right)}^{2} + 1\right)\\
\mathbf{if}\;\frac{2}{t_1 \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq 10^{+244}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot t_1\right) \cdot \left(\frac{{t}^{3}}{\ell} \cdot \frac{\sin k}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\end{array}
\end{array}
if (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) < 1.00000000000000007e244Initial program 82.5%
associate-*l*82.5%
+-commutative82.5%
Simplified82.5%
Taylor expanded in t around 0 83.0%
*-commutative69.7%
unpow269.7%
times-frac70.6%
Simplified86.1%
if 1.00000000000000007e244 < (/.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.5%
*-commutative23.5%
associate-*l*23.5%
associate-*r*23.5%
+-commutative23.5%
associate-+r+23.5%
metadata-eval23.5%
Simplified23.5%
add-cube-cbrt23.5%
pow323.5%
div-inv22.6%
cbrt-prod22.6%
unpow322.6%
add-cbrt-cube37.8%
pow237.8%
pow-flip38.0%
metadata-eval38.0%
Applied egg-rr38.0%
Taylor expanded in k around inf 60.3%
*-commutative60.3%
unpow260.3%
times-frac68.9%
unpow268.9%
Simplified68.9%
Taylor expanded in t around 0 60.3%
*-commutative60.3%
unpow260.3%
unpow260.3%
associate-*r*64.3%
times-frac84.4%
Simplified84.4%
Final simplification85.4%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(+ 1.0 (+ t_1 1.0))
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))))
4e+218)
(* l (* l (/ 2.0 (* (tan k) (* (+ 2.0 t_1) (* (sin k) (pow t 3.0)))))))
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))))) <= 4e+218) {
tmp = l * (l * (2.0 / (tan(k) * ((2.0 + t_1) * (sin(k) * pow(t, 3.0))))));
} else {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(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) :: t_1
real(8) :: tmp
t_1 = (k / t) ** 2.0d0
if ((2.0d0 / ((1.0d0 + (t_1 + 1.0d0)) * (tan(k) * (sin(k) * ((t ** 3.0d0) / (l * l)))))) <= 4d+218) then
tmp = l * (l * (2.0d0 / (tan(k) * ((2.0d0 + t_1) * (sin(k) * (t ** 3.0d0))))))
else
tmp = 2.0d0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))))) <= 4e+218) {
tmp = l * (l * (2.0 / (Math.tan(k) * ((2.0 + t_1) * (Math.sin(k) * Math.pow(t, 3.0))))));
} else {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow((k / t), 2.0) tmp = 0 if (2.0 / ((1.0 + (t_1 + 1.0)) * (math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))))) <= 4e+218: tmp = l * (l * (2.0 / (math.tan(k) * ((2.0 + t_1) * (math.sin(k) * math.pow(t, 3.0)))))) else: tmp = 2.0 / ((((t * k) / l) * (k / l)) * (math.tan(k) * math.sin(k))) return tmp
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(1.0 + Float64(t_1 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))))) <= 4e+218) tmp = Float64(l * Float64(l * Float64(2.0 / Float64(tan(k) * Float64(Float64(2.0 + t_1) * Float64(sin(k) * (t ^ 3.0))))))); else tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (k / t) ^ 2.0; tmp = 0.0; if ((2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))))) <= 4e+218) tmp = l * (l * (2.0 / (tan(k) * ((2.0 + t_1) * (sin(k) * (t ^ 3.0)))))); else tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(1.0 + N[(t$95$1 + 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], 4e+218], N[(l * N[(l * N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[(2.0 + t$95$1), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(1 + \left(t_1 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq 4 \cdot 10^{+218}:\\
\;\;\;\;\ell \cdot \left(\ell \cdot \frac{2}{\tan k \cdot \left(\left(2 + t_1\right) \cdot \left(\sin k \cdot {t}^{3}\right)\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\end{array}
\end{array}
if (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) < 4.00000000000000033e218Initial program 82.3%
associate-/l/82.3%
associate-*l/82.9%
associate-*l/80.9%
associate-/r/80.9%
*-commutative80.9%
associate-/l/80.8%
associate-*r*81.4%
*-commutative81.4%
associate-*r*81.5%
*-commutative81.5%
Simplified81.5%
expm1-log1p-u66.9%
expm1-udef60.0%
Applied egg-rr60.0%
expm1-def66.9%
expm1-log1p81.5%
associate-*l*84.1%
*-commutative84.1%
Simplified84.1%
if 4.00000000000000033e218 < (/.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 24.2%
*-commutative24.2%
associate-*l*23.3%
associate-*r*23.3%
+-commutative23.3%
associate-+r+23.3%
metadata-eval23.3%
Simplified23.3%
add-cube-cbrt23.3%
pow323.3%
div-inv22.4%
cbrt-prod22.4%
unpow322.4%
add-cbrt-cube37.5%
pow237.5%
pow-flip37.7%
metadata-eval37.7%
Applied egg-rr37.7%
Taylor expanded in k around inf 59.8%
*-commutative59.8%
unpow259.8%
times-frac68.3%
unpow268.3%
Simplified68.3%
Taylor expanded in t around 0 59.8%
*-commutative59.8%
unpow259.8%
unpow259.8%
associate-*r*63.8%
times-frac83.7%
Simplified83.7%
Final simplification83.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)) (t_2 (cbrt (sin k))))
(if (<= t -4.4e+44)
(* (/ 2.0 (pow (* (cbrt (* (tan k) (+ 2.0 t_1))) (* t t_2)) 3.0)) (* l l))
(if (<= t 8e-49)
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k))))
(/
2.0
(*
(pow (* t_2 (* t (cbrt (pow l -2.0)))) 3.0)
(* (tan k) (+ 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 = cbrt(sin(k));
double tmp;
if (t <= -4.4e+44) {
tmp = (2.0 / pow((cbrt((tan(k) * (2.0 + t_1))) * (t * t_2)), 3.0)) * (l * l);
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
} else {
tmp = 2.0 / (pow((t_2 * (t * cbrt(pow(l, -2.0)))), 3.0) * (tan(k) * (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 = Math.cbrt(Math.sin(k));
double tmp;
if (t <= -4.4e+44) {
tmp = (2.0 / Math.pow((Math.cbrt((Math.tan(k) * (2.0 + t_1))) * (t * t_2)), 3.0)) * (l * l);
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
} else {
tmp = 2.0 / (Math.pow((t_2 * (t * Math.cbrt(Math.pow(l, -2.0)))), 3.0) * (Math.tan(k) * (1.0 + (t_1 + 1.0))));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 t_2 = cbrt(sin(k)) tmp = 0.0 if (t <= -4.4e+44) tmp = Float64(Float64(2.0 / (Float64(cbrt(Float64(tan(k) * Float64(2.0 + t_1))) * Float64(t * t_2)) ^ 3.0)) * Float64(l * l)); elseif (t <= 8e-49) tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); else tmp = Float64(2.0 / Float64((Float64(t_2 * Float64(t * cbrt((l ^ -2.0)))) ^ 3.0) * Float64(tan(k) * 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[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]}, If[LessEqual[t, -4.4e+44], N[(N[(2.0 / N[Power[N[(N[Power[N[(N[Tan[k], $MachinePrecision] * N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * N[(t * t$95$2), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-49], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(t$95$2 * N[(t * N[Power[N[Power[l, -2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
t_2 := \sqrt[3]{\sin k}\\
\mathbf{if}\;t \leq -4.4 \cdot 10^{+44}:\\
\;\;\;\;\frac{2}{{\left(\sqrt[3]{\tan k \cdot \left(2 + t_1\right)} \cdot \left(t \cdot t_2\right)\right)}^{3}} \cdot \left(\ell \cdot \ell\right)\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(t_2 \cdot \left(t \cdot \sqrt[3]{{\ell}^{-2}}\right)\right)}^{3} \cdot \left(\tan k \cdot \left(1 + \left(t_1 + 1\right)\right)\right)}\\
\end{array}
\end{array}
if t < -4.39999999999999991e44Initial program 58.4%
associate-/l/58.4%
associate-*l/58.4%
associate-*l/59.8%
associate-/r/59.6%
*-commutative59.6%
associate-/l/59.6%
associate-*r*59.6%
*-commutative59.6%
associate-*r*59.6%
*-commutative59.6%
Simplified59.6%
add-cube-cbrt59.5%
pow359.5%
Applied egg-rr80.8%
if -4.39999999999999991e44 < t < 7.99999999999999949e-49Initial program 46.0%
*-commutative46.0%
associate-*l*45.3%
associate-*r*45.2%
+-commutative45.2%
associate-+r+45.2%
metadata-eval45.2%
Simplified45.2%
add-cube-cbrt45.2%
pow345.2%
div-inv44.4%
cbrt-prod44.4%
unpow344.4%
add-cbrt-cube51.4%
pow251.4%
pow-flip51.5%
metadata-eval51.5%
Applied egg-rr51.5%
Taylor expanded in k around inf 71.6%
*-commutative71.6%
unpow271.6%
times-frac81.8%
unpow281.8%
Simplified81.8%
Taylor expanded in t around 0 71.6%
*-commutative71.6%
unpow271.6%
unpow271.6%
associate-*r*75.1%
times-frac94.3%
Simplified94.3%
if 7.99999999999999949e-49 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
add-cube-cbrt76.6%
pow376.6%
cbrt-prod76.5%
div-inv76.5%
cbrt-prod77.7%
unpow377.7%
add-cbrt-cube84.3%
pow284.3%
pow-flip84.3%
metadata-eval84.3%
Applied egg-rr84.3%
Final simplification88.4%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* t (cbrt (sin k)))) (t_2 (* (tan k) (+ 2.0 (pow (/ k t) 2.0)))))
(if (<= t -8.5e+43)
(* (/ 2.0 (pow (* (cbrt t_2) t_1) 3.0)) (* l l))
(if (<= t 8.5e-72)
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k))))
(* l (* l (/ (/ 2.0 (pow t_1 3.0)) t_2)))))))
double code(double t, double l, double k) {
double t_1 = t * cbrt(sin(k));
double t_2 = tan(k) * (2.0 + pow((k / t), 2.0));
double tmp;
if (t <= -8.5e+43) {
tmp = (2.0 / pow((cbrt(t_2) * t_1), 3.0)) * (l * l);
} else if (t <= 8.5e-72) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
} else {
tmp = l * (l * ((2.0 / pow(t_1, 3.0)) / t_2));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = t * Math.cbrt(Math.sin(k));
double t_2 = Math.tan(k) * (2.0 + Math.pow((k / t), 2.0));
double tmp;
if (t <= -8.5e+43) {
tmp = (2.0 / Math.pow((Math.cbrt(t_2) * t_1), 3.0)) * (l * l);
} else if (t <= 8.5e-72) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
} else {
tmp = l * (l * ((2.0 / Math.pow(t_1, 3.0)) / t_2));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(t * cbrt(sin(k))) t_2 = Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))) tmp = 0.0 if (t <= -8.5e+43) tmp = Float64(Float64(2.0 / (Float64(cbrt(t_2) * t_1) ^ 3.0)) * Float64(l * l)); elseif (t <= 8.5e-72) tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); else tmp = Float64(l * Float64(l * Float64(Float64(2.0 / (t_1 ^ 3.0)) / t_2))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(t * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8.5e+43], N[(N[(2.0 / N[Power[N[(N[Power[t$95$2, 1/3], $MachinePrecision] * t$95$1), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.5e-72], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(l * N[(l * N[(N[(2.0 / N[Power[t$95$1, 3.0], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \sqrt[3]{\sin k}\\
t_2 := \tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\\
\mathbf{if}\;t \leq -8.5 \cdot 10^{+43}:\\
\;\;\;\;\frac{2}{{\left(\sqrt[3]{t_2} \cdot t_1\right)}^{3}} \cdot \left(\ell \cdot \ell\right)\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{-72}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\mathbf{else}:\\
\;\;\;\;\ell \cdot \left(\ell \cdot \frac{\frac{2}{{t_1}^{3}}}{t_2}\right)\\
\end{array}
\end{array}
if t < -8.5e43Initial program 58.4%
associate-/l/58.4%
associate-*l/58.4%
associate-*l/59.8%
associate-/r/59.6%
*-commutative59.6%
associate-/l/59.6%
associate-*r*59.6%
*-commutative59.6%
associate-*r*59.6%
*-commutative59.6%
Simplified59.6%
add-cube-cbrt59.5%
pow359.5%
Applied egg-rr80.8%
if -8.5e43 < t < 8.50000000000000008e-72Initial program 45.4%
*-commutative45.4%
associate-*l*44.7%
associate-*r*44.6%
+-commutative44.6%
associate-+r+44.6%
metadata-eval44.6%
Simplified44.6%
add-cube-cbrt44.6%
pow344.6%
div-inv43.8%
cbrt-prod43.7%
unpow343.7%
add-cbrt-cube51.0%
pow251.0%
pow-flip51.0%
metadata-eval51.0%
Applied egg-rr51.0%
Taylor expanded in k around inf 71.6%
*-commutative71.6%
unpow271.6%
times-frac81.4%
unpow281.4%
Simplified81.4%
Taylor expanded in t around 0 71.6%
*-commutative71.6%
unpow271.6%
unpow271.6%
associate-*r*75.2%
times-frac94.2%
Simplified94.2%
if 8.50000000000000008e-72 < t Initial program 76.5%
associate-/l/76.5%
associate-*l/77.7%
associate-*l/74.1%
associate-/r/73.0%
*-commutative73.0%
associate-/l/73.0%
associate-*r*73.0%
*-commutative73.0%
associate-*r*73.0%
*-commutative73.0%
Simplified73.0%
add-cube-cbrt72.8%
pow372.8%
cbrt-prod72.8%
cbrt-prod72.9%
unpow372.9%
add-cbrt-cube77.7%
Applied egg-rr77.7%
pow177.7%
*-commutative77.7%
Applied egg-rr77.7%
unpow177.7%
*-commutative77.7%
cube-prod77.7%
rem-cube-cbrt77.7%
associate-*l*77.7%
Simplified77.7%
expm1-log1p-u77.3%
expm1-udef72.6%
associate-*l*74.3%
*-commutative74.3%
Applied egg-rr74.3%
expm1-def80.1%
expm1-log1p81.6%
associate-/r*81.6%
Simplified81.6%
Final simplification87.4%
(FPCore (t l k)
:precision binary64
(if (<= t -1.08e+45)
(* (* l l) (/ 2.0 (pow (* (* t (cbrt (sin k))) (cbrt (* 2.0 k))) 3.0)))
(if (<= t 8e-49)
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k))))
(/ 2.0 (* (/ (* k (pow t 3.0)) (* l l)) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= -1.08e+45) {
tmp = (l * l) * (2.0 / pow(((t * cbrt(sin(k))) * cbrt((2.0 * k))), 3.0));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
} else {
tmp = 2.0 / (((k * pow(t, 3.0)) / (l * l)) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= -1.08e+45) {
tmp = (l * l) * (2.0 / Math.pow(((t * Math.cbrt(Math.sin(k))) * Math.cbrt((2.0 * k))), 3.0));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
} else {
tmp = 2.0 / (((k * Math.pow(t, 3.0)) / (l * l)) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= -1.08e+45) tmp = Float64(Float64(l * l) * Float64(2.0 / (Float64(Float64(t * cbrt(sin(k))) * cbrt(Float64(2.0 * k))) ^ 3.0))); elseif (t <= 8e-49) tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); else tmp = Float64(2.0 / Float64(Float64(Float64(k * (t ^ 3.0)) / Float64(l * l)) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, -1.08e+45], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[(t * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision] * N[Power[N[(2.0 * k), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-49], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.08 \cdot 10^{+45}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left(\left(t \cdot \sqrt[3]{\sin k}\right) \cdot \sqrt[3]{2 \cdot k}\right)}^{3}}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{k \cdot {t}^{3}}{\ell \cdot \ell} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < -1.08e45Initial program 58.4%
associate-/l/58.4%
associate-*l/58.4%
associate-*l/59.8%
associate-/r/59.6%
*-commutative59.6%
associate-/l/59.6%
associate-*r*59.6%
*-commutative59.6%
associate-*r*59.6%
*-commutative59.6%
Simplified59.6%
add-cube-cbrt59.5%
pow359.5%
Applied egg-rr80.8%
Taylor expanded in k around 0 75.7%
*-commutative75.7%
Simplified75.7%
if -1.08e45 < t < 7.99999999999999949e-49Initial program 46.0%
*-commutative46.0%
associate-*l*45.3%
associate-*r*45.2%
+-commutative45.2%
associate-+r+45.2%
metadata-eval45.2%
Simplified45.2%
add-cube-cbrt45.2%
pow345.2%
div-inv44.4%
cbrt-prod44.4%
unpow344.4%
add-cbrt-cube51.4%
pow251.4%
pow-flip51.5%
metadata-eval51.5%
Applied egg-rr51.5%
Taylor expanded in k around inf 71.6%
*-commutative71.6%
unpow271.6%
times-frac81.8%
unpow281.8%
Simplified81.8%
Taylor expanded in t around 0 71.6%
*-commutative71.6%
unpow271.6%
unpow271.6%
associate-*r*75.1%
times-frac94.3%
Simplified94.3%
if 7.99999999999999949e-49 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
Taylor expanded in k around 0 70.5%
Taylor expanded in k around 0 75.7%
unpow275.7%
Simplified75.7%
Final simplification84.8%
(FPCore (t l k)
:precision binary64
(if (<= t -7.5e+45)
(/ 2.0 (* (* 2.0 k) (* (sin k) (pow (* t (cbrt (pow l -2.0))) 3.0))))
(if (<= t 8e-49)
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k))))
(/ 2.0 (* (/ (* k (pow t 3.0)) (* l l)) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= -7.5e+45) {
tmp = 2.0 / ((2.0 * k) * (sin(k) * pow((t * cbrt(pow(l, -2.0))), 3.0)));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
} else {
tmp = 2.0 / (((k * pow(t, 3.0)) / (l * l)) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= -7.5e+45) {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * Math.pow((t * Math.cbrt(Math.pow(l, -2.0))), 3.0)));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
} else {
tmp = 2.0 / (((k * Math.pow(t, 3.0)) / (l * l)) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= -7.5e+45) tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * (Float64(t * cbrt((l ^ -2.0))) ^ 3.0)))); elseif (t <= 8e-49) tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); else tmp = Float64(2.0 / Float64(Float64(Float64(k * (t ^ 3.0)) / Float64(l * l)) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, -7.5e+45], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t * N[Power[N[Power[l, -2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-49], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7.5 \cdot 10^{+45}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot {\left(t \cdot \sqrt[3]{{\ell}^{-2}}\right)}^{3}\right)}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{k \cdot {t}^{3}}{\ell \cdot \ell} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < -7.50000000000000058e45Initial program 58.4%
associate-*l*58.4%
+-commutative58.4%
Simplified58.4%
Taylor expanded in k around 0 53.3%
add-cube-cbrt47.8%
pow347.8%
div-inv47.8%
cbrt-prod47.7%
unpow347.7%
add-cbrt-cube64.2%
pow264.2%
pow-flip64.4%
metadata-eval64.4%
Applied egg-rr68.1%
if -7.50000000000000058e45 < t < 7.99999999999999949e-49Initial program 46.0%
*-commutative46.0%
associate-*l*45.3%
associate-*r*45.2%
+-commutative45.2%
associate-+r+45.2%
metadata-eval45.2%
Simplified45.2%
add-cube-cbrt45.2%
pow345.2%
div-inv44.4%
cbrt-prod44.4%
unpow344.4%
add-cbrt-cube51.4%
pow251.4%
pow-flip51.5%
metadata-eval51.5%
Applied egg-rr51.5%
Taylor expanded in k around inf 71.6%
*-commutative71.6%
unpow271.6%
times-frac81.8%
unpow281.8%
Simplified81.8%
Taylor expanded in t around 0 71.6%
*-commutative71.6%
unpow271.6%
unpow271.6%
associate-*r*75.1%
times-frac94.3%
Simplified94.3%
if 7.99999999999999949e-49 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
Taylor expanded in k around 0 70.5%
Taylor expanded in k around 0 75.7%
unpow275.7%
Simplified75.7%
Final simplification83.2%
(FPCore (t l k)
:precision binary64
(if (<= t -2.4e+45)
(* (* l l) (/ 2.0 (* (pow (* t (cbrt (sin k))) 3.0) (* 2.0 k))))
(if (<= t 8e-49)
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k))))
(/ 2.0 (* (/ (* k (pow t 3.0)) (* l l)) (* 2.0 k))))))
double code(double t, double l, double k) {
double tmp;
if (t <= -2.4e+45) {
tmp = (l * l) * (2.0 / (pow((t * cbrt(sin(k))), 3.0) * (2.0 * k)));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
} else {
tmp = 2.0 / (((k * pow(t, 3.0)) / (l * l)) * (2.0 * k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= -2.4e+45) {
tmp = (l * l) * (2.0 / (Math.pow((t * Math.cbrt(Math.sin(k))), 3.0) * (2.0 * k)));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
} else {
tmp = 2.0 / (((k * Math.pow(t, 3.0)) / (l * l)) * (2.0 * k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= -2.4e+45) tmp = Float64(Float64(l * l) * Float64(2.0 / Float64((Float64(t * cbrt(sin(k))) ^ 3.0) * Float64(2.0 * k)))); elseif (t <= 8e-49) tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); else tmp = Float64(2.0 / Float64(Float64(Float64(k * (t ^ 3.0)) / Float64(l * l)) * Float64(2.0 * k))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, -2.4e+45], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[N[(t * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-49], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.4 \cdot 10^{+45}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left(t \cdot \sqrt[3]{\sin k}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{k \cdot {t}^{3}}{\ell \cdot \ell} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < -2.39999999999999989e45Initial program 58.4%
associate-/l/58.4%
associate-*l/58.4%
associate-*l/59.8%
associate-/r/59.6%
*-commutative59.6%
associate-/l/59.6%
associate-*r*59.6%
*-commutative59.6%
associate-*r*59.6%
*-commutative59.6%
Simplified59.6%
add-cube-cbrt59.5%
pow359.5%
cbrt-prod59.4%
cbrt-prod59.5%
unpow359.5%
add-cbrt-cube72.1%
Applied egg-rr72.1%
pow172.1%
*-commutative72.1%
Applied egg-rr72.1%
unpow172.1%
*-commutative72.1%
cube-prod72.1%
rem-cube-cbrt72.0%
associate-*l*72.0%
Simplified72.0%
Taylor expanded in k around 0 67.0%
*-commutative67.0%
Simplified67.0%
if -2.39999999999999989e45 < t < 7.99999999999999949e-49Initial program 46.0%
*-commutative46.0%
associate-*l*45.3%
associate-*r*45.2%
+-commutative45.2%
associate-+r+45.2%
metadata-eval45.2%
Simplified45.2%
add-cube-cbrt45.2%
pow345.2%
div-inv44.4%
cbrt-prod44.4%
unpow344.4%
add-cbrt-cube51.4%
pow251.4%
pow-flip51.5%
metadata-eval51.5%
Applied egg-rr51.5%
Taylor expanded in k around inf 71.6%
*-commutative71.6%
unpow271.6%
times-frac81.8%
unpow281.8%
Simplified81.8%
Taylor expanded in t around 0 71.6%
*-commutative71.6%
unpow271.6%
unpow271.6%
associate-*r*75.1%
times-frac94.3%
Simplified94.3%
if 7.99999999999999949e-49 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
Taylor expanded in k around 0 70.5%
Taylor expanded in k around 0 75.7%
unpow275.7%
Simplified75.7%
Final simplification82.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* k (pow t 3.0))))
(if (<= t -6e+167)
(* l (/ l (* k t_1)))
(if (<= t 8e-49)
(/ 2.0 (* (sin k) (* (tan k) (/ (* (/ k l) (* t k)) l))))
(/ 2.0 (* (/ t_1 (* l l)) (* 2.0 k)))))))
double code(double t, double l, double k) {
double t_1 = k * pow(t, 3.0);
double tmp;
if (t <= -6e+167) {
tmp = l * (l / (k * t_1));
} else if (t <= 8e-49) {
tmp = 2.0 / (sin(k) * (tan(k) * (((k / l) * (t * k)) / l)));
} else {
tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * 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) :: t_1
real(8) :: tmp
t_1 = k * (t ** 3.0d0)
if (t <= (-6d+167)) then
tmp = l * (l / (k * t_1))
else if (t <= 8d-49) then
tmp = 2.0d0 / (sin(k) * (tan(k) * (((k / l) * (t * k)) / l)))
else
tmp = 2.0d0 / ((t_1 / (l * l)) * (2.0d0 * k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = k * Math.pow(t, 3.0);
double tmp;
if (t <= -6e+167) {
tmp = l * (l / (k * t_1));
} else if (t <= 8e-49) {
tmp = 2.0 / (Math.sin(k) * (Math.tan(k) * (((k / l) * (t * k)) / l)));
} else {
tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k));
}
return tmp;
}
def code(t, l, k): t_1 = k * math.pow(t, 3.0) tmp = 0 if t <= -6e+167: tmp = l * (l / (k * t_1)) elif t <= 8e-49: tmp = 2.0 / (math.sin(k) * (math.tan(k) * (((k / l) * (t * k)) / l))) else: tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k)) return tmp
function code(t, l, k) t_1 = Float64(k * (t ^ 3.0)) tmp = 0.0 if (t <= -6e+167) tmp = Float64(l * Float64(l / Float64(k * t_1))); elseif (t <= 8e-49) tmp = Float64(2.0 / Float64(sin(k) * Float64(tan(k) * Float64(Float64(Float64(k / l) * Float64(t * k)) / l)))); else tmp = Float64(2.0 / Float64(Float64(t_1 / Float64(l * l)) * Float64(2.0 * k))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = k * (t ^ 3.0); tmp = 0.0; if (t <= -6e+167) tmp = l * (l / (k * t_1)); elseif (t <= 8e-49) tmp = 2.0 / (sin(k) * (tan(k) * (((k / l) * (t * k)) / l))); else tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k)); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6e+167], N[(l * N[(l / N[(k * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-49], N[(2.0 / N[(N[Sin[k], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[(N[(k / l), $MachinePrecision] * N[(t * k), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t$95$1 / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := k \cdot {t}^{3}\\
\mathbf{if}\;t \leq -6 \cdot 10^{+167}:\\
\;\;\;\;\ell \cdot \frac{\ell}{k \cdot t_1}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\sin k \cdot \left(\tan k \cdot \frac{\frac{k}{\ell} \cdot \left(t \cdot k\right)}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t_1}{\ell \cdot \ell} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < -6.00000000000000023e167Initial program 72.2%
associate-/l/72.2%
associate-*l/72.2%
associate-*l/72.2%
associate-/r/72.2%
*-commutative72.2%
associate-/l/72.2%
associate-*r*72.2%
*-commutative72.2%
associate-*r*72.2%
*-commutative72.2%
Simplified72.2%
add-cube-cbrt72.2%
pow372.2%
Applied egg-rr85.2%
pow185.2%
associate-*l*85.7%
Applied egg-rr85.7%
Taylor expanded in k around 0 53.1%
unpow253.1%
associate-*l*72.7%
Simplified72.7%
if -6.00000000000000023e167 < t < 7.99999999999999949e-49Initial program 46.8%
*-commutative46.8%
associate-*l*45.2%
associate-*r*45.2%
+-commutative45.2%
associate-+r+45.2%
metadata-eval45.2%
Simplified45.2%
add-cube-cbrt45.1%
pow345.1%
div-inv44.5%
cbrt-prod44.4%
unpow344.4%
add-cbrt-cube55.6%
pow255.6%
pow-flip55.7%
metadata-eval55.7%
Applied egg-rr55.7%
Taylor expanded in k around inf 67.9%
*-commutative67.9%
unpow267.9%
times-frac76.2%
unpow276.2%
Simplified76.2%
expm1-log1p-u65.4%
expm1-udef34.1%
associate-/l*36.2%
Applied egg-rr36.2%
expm1-def69.7%
expm1-log1p80.7%
*-commutative80.7%
associate-*l*81.4%
associate-*l/81.9%
*-commutative81.9%
associate-/r/81.8%
associate-*l*86.0%
Simplified86.0%
if 7.99999999999999949e-49 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
Taylor expanded in k around 0 70.5%
Taylor expanded in k around 0 75.7%
unpow275.7%
Simplified75.7%
Final simplification81.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* k (pow t 3.0))))
(if (<= t -4.8e+167)
(* l (/ l (* k t_1)))
(if (<= t 8e-49)
(/ 2.0 (* (* (/ (* t k) l) (/ k l)) (* (tan k) (sin k))))
(/ 2.0 (* (/ t_1 (* l l)) (* 2.0 k)))))))
double code(double t, double l, double k) {
double t_1 = k * pow(t, 3.0);
double tmp;
if (t <= -4.8e+167) {
tmp = l * (l / (k * t_1));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)));
} else {
tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * 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) :: t_1
real(8) :: tmp
t_1 = k * (t ** 3.0d0)
if (t <= (-4.8d+167)) then
tmp = l * (l / (k * t_1))
else if (t <= 8d-49) then
tmp = 2.0d0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k)))
else
tmp = 2.0d0 / ((t_1 / (l * l)) * (2.0d0 * k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = k * Math.pow(t, 3.0);
double tmp;
if (t <= -4.8e+167) {
tmp = l * (l / (k * t_1));
} else if (t <= 8e-49) {
tmp = 2.0 / ((((t * k) / l) * (k / l)) * (Math.tan(k) * Math.sin(k)));
} else {
tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k));
}
return tmp;
}
def code(t, l, k): t_1 = k * math.pow(t, 3.0) tmp = 0 if t <= -4.8e+167: tmp = l * (l / (k * t_1)) elif t <= 8e-49: tmp = 2.0 / ((((t * k) / l) * (k / l)) * (math.tan(k) * math.sin(k))) else: tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k)) return tmp
function code(t, l, k) t_1 = Float64(k * (t ^ 3.0)) tmp = 0.0 if (t <= -4.8e+167) tmp = Float64(l * Float64(l / Float64(k * t_1))); elseif (t <= 8e-49) tmp = Float64(2.0 / Float64(Float64(Float64(Float64(t * k) / l) * Float64(k / l)) * Float64(tan(k) * sin(k)))); else tmp = Float64(2.0 / Float64(Float64(t_1 / Float64(l * l)) * Float64(2.0 * k))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = k * (t ^ 3.0); tmp = 0.0; if (t <= -4.8e+167) tmp = l * (l / (k * t_1)); elseif (t <= 8e-49) tmp = 2.0 / ((((t * k) / l) * (k / l)) * (tan(k) * sin(k))); else tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k)); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.8e+167], N[(l * N[(l / N[(k * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-49], N[(2.0 / N[(N[(N[(N[(t * k), $MachinePrecision] / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t$95$1 / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := k \cdot {t}^{3}\\
\mathbf{if}\;t \leq -4.8 \cdot 10^{+167}:\\
\;\;\;\;\ell \cdot \frac{\ell}{k \cdot t_1}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{2}{\left(\frac{t \cdot k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \left(\tan k \cdot \sin k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t_1}{\ell \cdot \ell} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < -4.79999999999999998e167Initial program 72.2%
associate-/l/72.2%
associate-*l/72.2%
associate-*l/72.2%
associate-/r/72.2%
*-commutative72.2%
associate-/l/72.2%
associate-*r*72.2%
*-commutative72.2%
associate-*r*72.2%
*-commutative72.2%
Simplified72.2%
add-cube-cbrt72.2%
pow372.2%
Applied egg-rr85.2%
pow185.2%
associate-*l*85.7%
Applied egg-rr85.7%
Taylor expanded in k around 0 53.1%
unpow253.1%
associate-*l*72.7%
Simplified72.7%
if -4.79999999999999998e167 < t < 7.99999999999999949e-49Initial program 46.8%
*-commutative46.8%
associate-*l*45.2%
associate-*r*45.2%
+-commutative45.2%
associate-+r+45.2%
metadata-eval45.2%
Simplified45.2%
add-cube-cbrt45.1%
pow345.1%
div-inv44.5%
cbrt-prod44.4%
unpow344.4%
add-cbrt-cube55.6%
pow255.6%
pow-flip55.7%
metadata-eval55.7%
Applied egg-rr55.7%
Taylor expanded in k around inf 67.9%
*-commutative67.9%
unpow267.9%
times-frac76.2%
unpow276.2%
Simplified76.2%
Taylor expanded in t around 0 67.9%
*-commutative67.9%
unpow267.9%
unpow267.9%
associate-*r*70.6%
times-frac87.1%
Simplified87.1%
if 7.99999999999999949e-49 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
Taylor expanded in k around 0 70.5%
Taylor expanded in k around 0 75.7%
unpow275.7%
Simplified75.7%
Final simplification82.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ l (pow k 4.0))) (t_2 (* k (pow t 3.0))) (t_3 (* k t_2)))
(if (<= t -2.06e+167)
(* l (/ l t_3))
(if (<= t -1.65e+94)
(* 2.0 (/ (* l t_1) t))
(if (<= t -1.26e-104)
(/ (* (* l l) (cos k)) t_3)
(if (<= t 1.15e-51)
(* t_1 (/ 2.0 (/ t l)))
(/ 2.0 (* (/ t_2 (* l l)) (* 2.0 k)))))))))
double code(double t, double l, double k) {
double t_1 = l / pow(k, 4.0);
double t_2 = k * pow(t, 3.0);
double t_3 = k * t_2;
double tmp;
if (t <= -2.06e+167) {
tmp = l * (l / t_3);
} else if (t <= -1.65e+94) {
tmp = 2.0 * ((l * t_1) / t);
} else if (t <= -1.26e-104) {
tmp = ((l * l) * cos(k)) / t_3;
} else if (t <= 1.15e-51) {
tmp = t_1 * (2.0 / (t / l));
} else {
tmp = 2.0 / ((t_2 / (l * l)) * (2.0 * 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) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = l / (k ** 4.0d0)
t_2 = k * (t ** 3.0d0)
t_3 = k * t_2
if (t <= (-2.06d+167)) then
tmp = l * (l / t_3)
else if (t <= (-1.65d+94)) then
tmp = 2.0d0 * ((l * t_1) / t)
else if (t <= (-1.26d-104)) then
tmp = ((l * l) * cos(k)) / t_3
else if (t <= 1.15d-51) then
tmp = t_1 * (2.0d0 / (t / l))
else
tmp = 2.0d0 / ((t_2 / (l * l)) * (2.0d0 * k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = l / Math.pow(k, 4.0);
double t_2 = k * Math.pow(t, 3.0);
double t_3 = k * t_2;
double tmp;
if (t <= -2.06e+167) {
tmp = l * (l / t_3);
} else if (t <= -1.65e+94) {
tmp = 2.0 * ((l * t_1) / t);
} else if (t <= -1.26e-104) {
tmp = ((l * l) * Math.cos(k)) / t_3;
} else if (t <= 1.15e-51) {
tmp = t_1 * (2.0 / (t / l));
} else {
tmp = 2.0 / ((t_2 / (l * l)) * (2.0 * k));
}
return tmp;
}
def code(t, l, k): t_1 = l / math.pow(k, 4.0) t_2 = k * math.pow(t, 3.0) t_3 = k * t_2 tmp = 0 if t <= -2.06e+167: tmp = l * (l / t_3) elif t <= -1.65e+94: tmp = 2.0 * ((l * t_1) / t) elif t <= -1.26e-104: tmp = ((l * l) * math.cos(k)) / t_3 elif t <= 1.15e-51: tmp = t_1 * (2.0 / (t / l)) else: tmp = 2.0 / ((t_2 / (l * l)) * (2.0 * k)) return tmp
function code(t, l, k) t_1 = Float64(l / (k ^ 4.0)) t_2 = Float64(k * (t ^ 3.0)) t_3 = Float64(k * t_2) tmp = 0.0 if (t <= -2.06e+167) tmp = Float64(l * Float64(l / t_3)); elseif (t <= -1.65e+94) tmp = Float64(2.0 * Float64(Float64(l * t_1) / t)); elseif (t <= -1.26e-104) tmp = Float64(Float64(Float64(l * l) * cos(k)) / t_3); elseif (t <= 1.15e-51) tmp = Float64(t_1 * Float64(2.0 / Float64(t / l))); else tmp = Float64(2.0 / Float64(Float64(t_2 / Float64(l * l)) * Float64(2.0 * k))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = l / (k ^ 4.0); t_2 = k * (t ^ 3.0); t_3 = k * t_2; tmp = 0.0; if (t <= -2.06e+167) tmp = l * (l / t_3); elseif (t <= -1.65e+94) tmp = 2.0 * ((l * t_1) / t); elseif (t <= -1.26e-104) tmp = ((l * l) * cos(k)) / t_3; elseif (t <= 1.15e-51) tmp = t_1 * (2.0 / (t / l)); else tmp = 2.0 / ((t_2 / (l * l)) * (2.0 * k)); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(k * t$95$2), $MachinePrecision]}, If[LessEqual[t, -2.06e+167], N[(l * N[(l / t$95$3), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.65e+94], N[(2.0 * N[(N[(l * t$95$1), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.26e-104], N[(N[(N[(l * l), $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision], If[LessEqual[t, 1.15e-51], N[(t$95$1 * N[(2.0 / N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t$95$2 / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\ell}{{k}^{4}}\\
t_2 := k \cdot {t}^{3}\\
t_3 := k \cdot t_2\\
\mathbf{if}\;t \leq -2.06 \cdot 10^{+167}:\\
\;\;\;\;\ell \cdot \frac{\ell}{t_3}\\
\mathbf{elif}\;t \leq -1.65 \cdot 10^{+94}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot t_1}{t}\\
\mathbf{elif}\;t \leq -1.26 \cdot 10^{-104}:\\
\;\;\;\;\frac{\left(\ell \cdot \ell\right) \cdot \cos k}{t_3}\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-51}:\\
\;\;\;\;t_1 \cdot \frac{2}{\frac{t}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t_2}{\ell \cdot \ell} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < -2.06e167Initial program 72.2%
associate-/l/72.2%
associate-*l/72.2%
associate-*l/72.2%
associate-/r/72.2%
*-commutative72.2%
associate-/l/72.2%
associate-*r*72.2%
*-commutative72.2%
associate-*r*72.2%
*-commutative72.2%
Simplified72.2%
add-cube-cbrt72.2%
pow372.2%
Applied egg-rr85.2%
pow185.2%
associate-*l*85.7%
Applied egg-rr85.7%
Taylor expanded in k around 0 53.1%
unpow253.1%
associate-*l*72.7%
Simplified72.7%
if -2.06e167 < t < -1.65e94Initial program 35.4%
associate-/l/35.4%
associate-*l/35.4%
associate-*l/35.4%
associate-/r/35.2%
*-commutative35.2%
associate-/l/35.2%
associate-*r*35.2%
*-commutative35.2%
associate-*r*35.2%
*-commutative35.2%
Simplified35.2%
Taylor expanded in k around inf 64.8%
*-commutative64.8%
associate-*l*64.8%
*-commutative64.8%
unpow264.8%
associate-*l*64.8%
Simplified64.8%
Taylor expanded in k around 0 64.8%
unpow264.8%
*-commutative64.8%
times-frac65.1%
Simplified65.1%
associate-*l/65.2%
Applied egg-rr65.2%
if -1.65e94 < t < -1.26e-104Initial program 75.8%
associate-/l/75.8%
associate-*l/75.8%
associate-*l/75.5%
associate-/r/75.5%
*-commutative75.5%
associate-/l/75.4%
associate-*r*75.5%
*-commutative75.5%
associate-*r*75.4%
*-commutative75.4%
Simplified75.4%
Taylor expanded in t around inf 51.8%
unpow251.8%
Simplified51.8%
Taylor expanded in k around 0 61.2%
unpow256.9%
associate-*l*58.9%
Simplified63.4%
if -1.26e-104 < t < 1.15000000000000001e-51Initial program 32.1%
*-commutative32.1%
associate-*l*32.1%
associate-*r*32.0%
+-commutative32.0%
associate-+r+32.0%
metadata-eval32.0%
Simplified32.0%
add-cube-cbrt32.0%
pow332.0%
div-inv30.9%
cbrt-prod30.8%
unpow330.8%
add-cbrt-cube41.2%
pow241.2%
pow-flip41.3%
metadata-eval41.3%
Applied egg-rr41.3%
Taylor expanded in k around inf 67.4%
*-commutative67.4%
unpow267.4%
times-frac80.1%
unpow280.1%
Simplified80.1%
Taylor expanded in k around 0 57.1%
unpow257.1%
*-commutative57.1%
times-frac68.4%
associate-/r/68.3%
associate-*r/68.3%
associate-/r/68.1%
times-frac68.4%
Simplified68.4%
if 1.15000000000000001e-51 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
Taylor expanded in k around 0 70.5%
Taylor expanded in k around 0 75.7%
unpow275.7%
Simplified75.7%
Final simplification69.6%
(FPCore (t l k) :precision binary64 (if (<= k 1.3e-15) (/ 2.0 (* (* (/ (pow t 3.0) l) (/ (sin k) l)) (* 2.0 k))) (* (* l l) (/ 2.0 (* (tan k) (* (sin k) (* k (* t k))))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 1.3e-15) {
tmp = 2.0 / (((pow(t, 3.0) / l) * (sin(k) / l)) * (2.0 * k));
} else {
tmp = (l * l) * (2.0 / (tan(k) * (sin(k) * (k * (t * 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 (k <= 1.3d-15) then
tmp = 2.0d0 / ((((t ** 3.0d0) / l) * (sin(k) / l)) * (2.0d0 * k))
else
tmp = (l * l) * (2.0d0 / (tan(k) * (sin(k) * (k * (t * k)))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 1.3e-15) {
tmp = 2.0 / (((Math.pow(t, 3.0) / l) * (Math.sin(k) / l)) * (2.0 * k));
} else {
tmp = (l * l) * (2.0 / (Math.tan(k) * (Math.sin(k) * (k * (t * k)))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 1.3e-15: tmp = 2.0 / (((math.pow(t, 3.0) / l) * (math.sin(k) / l)) * (2.0 * k)) else: tmp = (l * l) * (2.0 / (math.tan(k) * (math.sin(k) * (k * (t * k))))) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 1.3e-15) tmp = Float64(2.0 / Float64(Float64(Float64((t ^ 3.0) / l) * Float64(sin(k) / l)) * Float64(2.0 * k))); else tmp = Float64(Float64(l * l) * Float64(2.0 / Float64(tan(k) * Float64(sin(k) * Float64(k * Float64(t * k)))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 1.3e-15) tmp = 2.0 / ((((t ^ 3.0) / l) * (sin(k) / l)) * (2.0 * k)); else tmp = (l * l) * (2.0 / (tan(k) * (sin(k) * (k * (t * k))))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 1.3e-15], N[(2.0 / N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(k * N[(t * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 1.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{2}{\left(\frac{{t}^{3}}{\ell} \cdot \frac{\sin k}{\ell}\right) \cdot \left(2 \cdot k\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{\tan k \cdot \left(\sin k \cdot \left(k \cdot \left(t \cdot k\right)\right)\right)}\\
\end{array}
\end{array}
if k < 1.30000000000000002e-15Initial program 58.8%
associate-*l*58.8%
+-commutative58.8%
Simplified58.8%
Taylor expanded in k around 0 59.2%
Taylor expanded in t around 0 59.6%
*-commutative59.6%
unpow259.6%
times-frac64.9%
Simplified64.9%
if 1.30000000000000002e-15 < k Initial program 55.4%
associate-/l/55.4%
associate-*l/55.4%
associate-*l/55.4%
associate-/r/55.4%
*-commutative55.4%
associate-/l/55.4%
associate-*r*55.4%
*-commutative55.4%
associate-*r*55.4%
*-commutative55.4%
Simplified55.4%
Taylor expanded in k around inf 70.2%
*-commutative70.2%
associate-*l*70.2%
*-commutative70.2%
unpow270.2%
associate-*l*73.4%
Simplified73.4%
Final simplification67.3%
(FPCore (t l k) :precision binary64 (if (<= k 6e+35) (/ 2.0 (* (* (/ (pow t 3.0) l) (/ (sin k) l)) (* 2.0 k))) (* (* l l) (/ 2.0 (* (tan k) (* t (pow k 3.0)))))))
double code(double t, double l, double k) {
double tmp;
if (k <= 6e+35) {
tmp = 2.0 / (((pow(t, 3.0) / l) * (sin(k) / l)) * (2.0 * k));
} else {
tmp = (l * l) * (2.0 / (tan(k) * (t * pow(k, 3.0))));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 6d+35) then
tmp = 2.0d0 / ((((t ** 3.0d0) / l) * (sin(k) / l)) * (2.0d0 * k))
else
tmp = (l * l) * (2.0d0 / (tan(k) * (t * (k ** 3.0d0))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 6e+35) {
tmp = 2.0 / (((Math.pow(t, 3.0) / l) * (Math.sin(k) / l)) * (2.0 * k));
} else {
tmp = (l * l) * (2.0 / (Math.tan(k) * (t * Math.pow(k, 3.0))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 6e+35: tmp = 2.0 / (((math.pow(t, 3.0) / l) * (math.sin(k) / l)) * (2.0 * k)) else: tmp = (l * l) * (2.0 / (math.tan(k) * (t * math.pow(k, 3.0)))) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 6e+35) tmp = Float64(2.0 / Float64(Float64(Float64((t ^ 3.0) / l) * Float64(sin(k) / l)) * Float64(2.0 * k))); else tmp = Float64(Float64(l * l) * Float64(2.0 / Float64(tan(k) * Float64(t * (k ^ 3.0))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 6e+35) tmp = 2.0 / ((((t ^ 3.0) / l) * (sin(k) / l)) * (2.0 * k)); else tmp = (l * l) * (2.0 / (tan(k) * (t * (k ^ 3.0)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 6e+35], N[(2.0 / N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(t * N[Power[k, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 6 \cdot 10^{+35}:\\
\;\;\;\;\frac{2}{\left(\frac{{t}^{3}}{\ell} \cdot \frac{\sin k}{\ell}\right) \cdot \left(2 \cdot k\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{\tan k \cdot \left(t \cdot {k}^{3}\right)}\\
\end{array}
\end{array}
if k < 5.99999999999999981e35Initial program 60.6%
associate-*l*60.6%
+-commutative60.6%
Simplified60.6%
Taylor expanded in k around 0 58.2%
Taylor expanded in t around 0 58.6%
*-commutative58.6%
unpow258.6%
times-frac63.0%
Simplified63.0%
if 5.99999999999999981e35 < k Initial program 48.2%
associate-/l/48.2%
associate-*l/48.2%
associate-*l/48.2%
associate-/r/48.2%
*-commutative48.2%
associate-/l/48.2%
associate-*r*48.2%
*-commutative48.2%
associate-*r*48.2%
*-commutative48.2%
Simplified48.2%
Taylor expanded in k around inf 68.6%
*-commutative68.6%
associate-*l*68.6%
*-commutative68.6%
unpow268.6%
associate-*l*72.7%
Simplified72.7%
Taylor expanded in k around 0 55.3%
Final simplification61.3%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* k (pow t 3.0))))
(if (<= t -1.12e+167)
(/ (* l l) (* k t_1))
(if (<= t 2.6e-50)
(* 2.0 (/ (* l (/ l (pow k 4.0))) t))
(/ 2.0 (* (/ t_1 (* l l)) (* 2.0 k)))))))
double code(double t, double l, double k) {
double t_1 = k * pow(t, 3.0);
double tmp;
if (t <= -1.12e+167) {
tmp = (l * l) / (k * t_1);
} else if (t <= 2.6e-50) {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
} else {
tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * 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) :: t_1
real(8) :: tmp
t_1 = k * (t ** 3.0d0)
if (t <= (-1.12d+167)) then
tmp = (l * l) / (k * t_1)
else if (t <= 2.6d-50) then
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
else
tmp = 2.0d0 / ((t_1 / (l * l)) * (2.0d0 * k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = k * Math.pow(t, 3.0);
double tmp;
if (t <= -1.12e+167) {
tmp = (l * l) / (k * t_1);
} else if (t <= 2.6e-50) {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
} else {
tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k));
}
return tmp;
}
def code(t, l, k): t_1 = k * math.pow(t, 3.0) tmp = 0 if t <= -1.12e+167: tmp = (l * l) / (k * t_1) elif t <= 2.6e-50: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) else: tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k)) return tmp
function code(t, l, k) t_1 = Float64(k * (t ^ 3.0)) tmp = 0.0 if (t <= -1.12e+167) tmp = Float64(Float64(l * l) / Float64(k * t_1)); elseif (t <= 2.6e-50) tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); else tmp = Float64(2.0 / Float64(Float64(t_1 / Float64(l * l)) * Float64(2.0 * k))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = k * (t ^ 3.0); tmp = 0.0; if (t <= -1.12e+167) tmp = (l * l) / (k * t_1); elseif (t <= 2.6e-50) tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); else tmp = 2.0 / ((t_1 / (l * l)) * (2.0 * k)); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.12e+167], N[(N[(l * l), $MachinePrecision] / N[(k * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.6e-50], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t$95$1 / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := k \cdot {t}^{3}\\
\mathbf{if}\;t \leq -1.12 \cdot 10^{+167}:\\
\;\;\;\;\frac{\ell \cdot \ell}{k \cdot t_1}\\
\mathbf{elif}\;t \leq 2.6 \cdot 10^{-50}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t_1}{\ell \cdot \ell} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < -1.11999999999999999e167Initial program 72.2%
associate-/l/72.2%
associate-*l/72.2%
associate-*l/72.2%
associate-/r/72.2%
*-commutative72.2%
associate-/l/72.2%
associate-*r*72.2%
*-commutative72.2%
associate-*r*72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in t around inf 52.6%
unpow252.6%
Simplified52.6%
Taylor expanded in k around 0 52.6%
unpow252.6%
Simplified52.6%
Taylor expanded in k around 0 52.6%
unpow252.6%
associate-*l*72.2%
Simplified72.2%
if -1.11999999999999999e167 < t < 2.6000000000000001e-50Initial program 46.8%
associate-/l/46.8%
associate-*l/46.7%
associate-*l/46.1%
associate-/r/46.7%
*-commutative46.7%
associate-/l/46.6%
associate-*r*47.2%
*-commutative47.2%
associate-*r*47.2%
*-commutative47.2%
Simplified47.2%
Taylor expanded in k around inf 67.6%
*-commutative67.6%
associate-*l*67.6%
*-commutative67.6%
unpow267.6%
associate-*l*70.3%
Simplified70.3%
Taylor expanded in k around 0 57.2%
unpow257.2%
*-commutative57.2%
times-frac63.5%
Simplified63.5%
associate-*l/63.5%
Applied egg-rr63.5%
if 2.6000000000000001e-50 < t Initial program 76.8%
associate-*l*76.8%
+-commutative76.8%
Simplified76.8%
Taylor expanded in k around 0 70.5%
Taylor expanded in k around 0 75.7%
unpow275.7%
Simplified75.7%
Final simplification67.9%
(FPCore (t l k) :precision binary64 (if (or (<= t -4.6e+167) (not (<= t 8e-49))) (/ (* l l) (* k (* k (pow t 3.0)))) (* 2.0 (/ (* l (/ l (pow k 4.0))) t))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -4.6e+167) || !(t <= 8e-49)) {
tmp = (l * l) / (k * (k * pow(t, 3.0)));
} else {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((t <= (-4.6d+167)) .or. (.not. (t <= 8d-49))) then
tmp = (l * l) / (k * (k * (t ** 3.0d0)))
else
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -4.6e+167) || !(t <= 8e-49)) {
tmp = (l * l) / (k * (k * Math.pow(t, 3.0)));
} else {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -4.6e+167) or not (t <= 8e-49): tmp = (l * l) / (k * (k * math.pow(t, 3.0))) else: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -4.6e+167) || !(t <= 8e-49)) tmp = Float64(Float64(l * l) / Float64(k * Float64(k * (t ^ 3.0)))); else tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -4.6e+167) || ~((t <= 8e-49))) tmp = (l * l) / (k * (k * (t ^ 3.0))); else tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -4.6e+167], N[Not[LessEqual[t, 8e-49]], $MachinePrecision]], N[(N[(l * l), $MachinePrecision] / N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.6 \cdot 10^{+167} \lor \neg \left(t \leq 8 \cdot 10^{-49}\right):\\
\;\;\;\;\frac{\ell \cdot \ell}{k \cdot \left(k \cdot {t}^{3}\right)}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\end{array}
\end{array}
if t < -4.59999999999999976e167 or 7.99999999999999949e-49 < t Initial program 75.8%
associate-/l/75.8%
associate-*l/76.8%
associate-*l/73.8%
associate-/r/72.9%
*-commutative72.9%
associate-/l/72.9%
associate-*r*72.9%
*-commutative72.9%
associate-*r*72.9%
*-commutative72.9%
Simplified72.9%
Taylor expanded in t around inf 58.4%
unpow258.4%
Simplified58.4%
Taylor expanded in k around 0 58.4%
unpow258.4%
Simplified58.4%
Taylor expanded in k around 0 63.5%
unpow263.5%
associate-*l*72.0%
Simplified72.0%
if -4.59999999999999976e167 < t < 7.99999999999999949e-49Initial program 46.8%
associate-/l/46.8%
associate-*l/46.7%
associate-*l/46.1%
associate-/r/46.7%
*-commutative46.7%
associate-/l/46.6%
associate-*r*47.2%
*-commutative47.2%
associate-*r*47.2%
*-commutative47.2%
Simplified47.2%
Taylor expanded in k around inf 67.6%
*-commutative67.6%
associate-*l*67.6%
*-commutative67.6%
unpow267.6%
associate-*l*70.3%
Simplified70.3%
Taylor expanded in k around 0 57.2%
unpow257.2%
*-commutative57.2%
times-frac63.5%
Simplified63.5%
associate-*l/63.5%
Applied egg-rr63.5%
Final simplification66.7%
(FPCore (t l k) :precision binary64 (if (<= t 3.8e-46) (* 2.0 (/ (* l (/ l (pow k 4.0))) t)) (* (* l (pow t -3.0)) (/ l (* k k)))))
double code(double t, double l, double k) {
double tmp;
if (t <= 3.8e-46) {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
} else {
tmp = (l * pow(t, -3.0)) * (l / (k * 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 <= 3.8d-46) then
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
else
tmp = (l * (t ** (-3.0d0))) * (l / (k * k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 3.8e-46) {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
} else {
tmp = (l * Math.pow(t, -3.0)) * (l / (k * k));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 3.8e-46: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) else: tmp = (l * math.pow(t, -3.0)) * (l / (k * k)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 3.8e-46) tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); else tmp = Float64(Float64(l * (t ^ -3.0)) * Float64(l / Float64(k * k))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 3.8e-46) tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); else tmp = (l * (t ^ -3.0)) * (l / (k * k)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 3.8e-46], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(N[(l * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision] * N[(l / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.8 \cdot 10^{-46}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot {t}^{-3}\right) \cdot \frac{\ell}{k \cdot k}\\
\end{array}
\end{array}
if t < 3.7999999999999997e-46Initial program 50.1%
associate-/l/50.1%
associate-*l/50.0%
associate-*l/49.4%
associate-/r/49.9%
*-commutative49.9%
associate-/l/49.9%
associate-*r*50.4%
*-commutative50.4%
associate-*r*50.4%
*-commutative50.4%
Simplified50.4%
Taylor expanded in k around inf 64.5%
*-commutative64.5%
associate-*l*64.5%
*-commutative64.5%
unpow264.5%
associate-*l*66.9%
Simplified66.9%
Taylor expanded in k around 0 55.4%
unpow255.4%
*-commutative55.4%
times-frac60.9%
Simplified60.9%
associate-*l/61.0%
Applied egg-rr61.0%
if 3.7999999999999997e-46 < t Initial program 76.5%
associate-/l/76.5%
associate-*l/77.8%
associate-*l/74.0%
associate-/r/72.7%
*-commutative72.7%
associate-/l/72.7%
associate-*r*72.7%
*-commutative72.7%
associate-*r*72.7%
*-commutative72.7%
Simplified72.7%
Taylor expanded in k around 0 66.0%
unpow266.0%
*-commutative66.0%
times-frac68.8%
unpow268.8%
Simplified68.8%
expm1-log1p-u60.8%
expm1-udef55.3%
div-inv55.3%
pow-flip55.3%
metadata-eval55.3%
Applied egg-rr55.3%
expm1-def60.8%
expm1-log1p68.8%
Simplified68.8%
Final simplification63.3%
(FPCore (t l k) :precision binary64 (if (<= k 6.5e+83) (* l (/ l (* k (* k (pow t 3.0))))) (* 2.0 (/ (* l (/ l (pow k 4.0))) t))))
double code(double t, double l, double k) {
double tmp;
if (k <= 6.5e+83) {
tmp = l * (l / (k * (k * pow(t, 3.0))));
} else {
tmp = 2.0 * ((l * (l / pow(k, 4.0))) / t);
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 6.5d+83) then
tmp = l * (l / (k * (k * (t ** 3.0d0))))
else
tmp = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 6.5e+83) {
tmp = l * (l / (k * (k * Math.pow(t, 3.0))));
} else {
tmp = 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 6.5e+83: tmp = l * (l / (k * (k * math.pow(t, 3.0)))) else: tmp = 2.0 * ((l * (l / math.pow(k, 4.0))) / t) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 6.5e+83) tmp = Float64(l * Float64(l / Float64(k * Float64(k * (t ^ 3.0))))); else tmp = Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 6.5e+83) tmp = l * (l / (k * (k * (t ^ 3.0)))); else tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 6.5e+83], N[(l * N[(l / N[(k * N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 6.5 \cdot 10^{+83}:\\
\;\;\;\;\ell \cdot \frac{\ell}{k \cdot \left(k \cdot {t}^{3}\right)}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}\\
\end{array}
\end{array}
if k < 6.5000000000000003e83Initial program 60.3%
associate-/l/60.3%
associate-*l/60.7%
associate-*l/58.8%
associate-/r/58.8%
*-commutative58.8%
associate-/l/58.8%
associate-*r*59.2%
*-commutative59.2%
associate-*r*59.2%
*-commutative59.2%
Simplified59.2%
add-cube-cbrt59.1%
pow359.1%
Applied egg-rr69.7%
pow169.7%
associate-*l*75.6%
Applied egg-rr75.6%
Taylor expanded in k around 0 57.3%
unpow257.3%
associate-*l*62.7%
Simplified62.7%
if 6.5000000000000003e83 < k Initial program 47.8%
associate-/l/47.8%
associate-*l/47.8%
associate-*l/47.8%
associate-/r/47.8%
*-commutative47.8%
associate-/l/47.8%
associate-*r*47.8%
*-commutative47.8%
associate-*r*47.8%
*-commutative47.8%
Simplified47.8%
Taylor expanded in k around inf 66.7%
*-commutative66.7%
associate-*l*66.7%
*-commutative66.7%
unpow266.7%
associate-*l*71.2%
Simplified71.2%
Taylor expanded in k around 0 55.9%
unpow255.9%
*-commutative55.9%
times-frac56.4%
Simplified56.4%
associate-*l/56.6%
Applied egg-rr56.6%
Final simplification61.5%
(FPCore (t l k) :precision binary64 (* 2.0 (* (/ l (pow k 4.0)) (/ l t))))
double code(double t, double l, double k) {
return 2.0 * ((l / pow(k, 4.0)) * (l / t));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 * ((l / (k ** 4.0d0)) * (l / t))
end function
public static double code(double t, double l, double k) {
return 2.0 * ((l / Math.pow(k, 4.0)) * (l / t));
}
def code(t, l, k): return 2.0 * ((l / math.pow(k, 4.0)) * (l / t))
function code(t, l, k) return Float64(2.0 * Float64(Float64(l / (k ^ 4.0)) * Float64(l / t))) end
function tmp = code(t, l, k) tmp = 2.0 * ((l / (k ^ 4.0)) * (l / t)); end
code[t_, l_, k_] := N[(2.0 * N[(N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\frac{\ell}{{k}^{4}} \cdot \frac{\ell}{t}\right)
\end{array}
Initial program 57.8%
associate-/l/57.8%
associate-*l/58.1%
associate-*l/56.6%
associate-/r/56.6%
*-commutative56.6%
associate-/l/56.6%
associate-*r*56.9%
*-commutative56.9%
associate-*r*56.9%
*-commutative56.9%
Simplified56.9%
Taylor expanded in k around inf 59.0%
*-commutative59.0%
associate-*l*59.1%
*-commutative59.1%
unpow259.1%
associate-*l*60.7%
Simplified60.7%
Taylor expanded in k around 0 52.2%
unpow252.2%
*-commutative52.2%
times-frac55.8%
Simplified55.8%
Final simplification55.8%
(FPCore (t l k) :precision binary64 (* 2.0 (/ (* l (/ l (pow k 4.0))) t)))
double code(double t, double l, double k) {
return 2.0 * ((l * (l / pow(k, 4.0))) / t);
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end function
public static double code(double t, double l, double k) {
return 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
def code(t, l, k): return 2.0 * ((l * (l / math.pow(k, 4.0))) / t)
function code(t, l, k) return Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)) end
function tmp = code(t, l, k) tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end
code[t_, l_, k_] := N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}
\end{array}
Initial program 57.8%
associate-/l/57.8%
associate-*l/58.1%
associate-*l/56.6%
associate-/r/56.6%
*-commutative56.6%
associate-/l/56.6%
associate-*r*56.9%
*-commutative56.9%
associate-*r*56.9%
*-commutative56.9%
Simplified56.9%
Taylor expanded in k around inf 59.0%
*-commutative59.0%
associate-*l*59.1%
*-commutative59.1%
unpow259.1%
associate-*l*60.7%
Simplified60.7%
Taylor expanded in k around 0 52.2%
unpow252.2%
*-commutative52.2%
times-frac55.8%
Simplified55.8%
associate-*l/55.9%
Applied egg-rr55.9%
Final simplification55.9%
herbie shell --seed 2023200
(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))))