
(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 25 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (- (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) - 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) - 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) - 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) - 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) - 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) - 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) - 1\right)}
\end{array}
(FPCore (t l k)
:precision binary64
(let* ((t_1 (cbrt (* (sin k) (tan k))))
(t_2 (/ (sqrt 2.0) (/ k t)))
(t_3 (/ t (pow (cbrt l) 2.0)))
(t_4 (* t_1 t_3)))
(if (<= (* l l) 0.0)
(*
(* t (* (/ (sqrt 2.0) k) (pow (* t (* (pow (cbrt l) -2.0) t_1)) -2.0)))
(/ t_2 t_4))
(if (<= (* l l) 5e+243)
(*
-2.0
(/
(/ (* (pow l 2.0) (cos k)) (pow k 2.0))
(* t (- (pow (sin k) 2.0)))))
(* (/ t_2 (pow t_4 2.0)) (/ t_2 (* t_3 (pow (cbrt t_1) 3.0))))))))
double code(double t, double l, double k) {
double t_1 = cbrt((sin(k) * tan(k)));
double t_2 = sqrt(2.0) / (k / t);
double t_3 = t / pow(cbrt(l), 2.0);
double t_4 = t_1 * t_3;
double tmp;
if ((l * l) <= 0.0) {
tmp = (t * ((sqrt(2.0) / k) * pow((t * (pow(cbrt(l), -2.0) * t_1)), -2.0))) * (t_2 / t_4);
} else if ((l * l) <= 5e+243) {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
} else {
tmp = (t_2 / pow(t_4, 2.0)) * (t_2 / (t_3 * pow(cbrt(t_1), 3.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_2 = Math.sqrt(2.0) / (k / t);
double t_3 = t / Math.pow(Math.cbrt(l), 2.0);
double t_4 = t_1 * t_3;
double tmp;
if ((l * l) <= 0.0) {
tmp = (t * ((Math.sqrt(2.0) / k) * Math.pow((t * (Math.pow(Math.cbrt(l), -2.0) * t_1)), -2.0))) * (t_2 / t_4);
} else if ((l * l) <= 5e+243) {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
} else {
tmp = (t_2 / Math.pow(t_4, 2.0)) * (t_2 / (t_3 * Math.pow(Math.cbrt(t_1), 3.0)));
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(Float64(sin(k) * tan(k))) t_2 = Float64(sqrt(2.0) / Float64(k / t)) t_3 = Float64(t / (cbrt(l) ^ 2.0)) t_4 = Float64(t_1 * t_3) tmp = 0.0 if (Float64(l * l) <= 0.0) tmp = Float64(Float64(t * Float64(Float64(sqrt(2.0) / k) * (Float64(t * Float64((cbrt(l) ^ -2.0) * t_1)) ^ -2.0))) * Float64(t_2 / t_4)); elseif (Float64(l * l) <= 5e+243) tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); else tmp = Float64(Float64(t_2 / (t_4 ^ 2.0)) * Float64(t_2 / Float64(t_3 * (cbrt(t_1) ^ 3.0)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[2.0], $MachinePrecision] / N[(k / t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$1 * t$95$3), $MachinePrecision]}, If[LessEqual[N[(l * l), $MachinePrecision], 0.0], N[(N[(t * N[(N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision] * N[Power[N[(t * N[(N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$2 / t$95$4), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 5e+243], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$2 / N[Power[t$95$4, 2.0], $MachinePrecision]), $MachinePrecision] * N[(t$95$2 / N[(t$95$3 * N[Power[N[Power[t$95$1, 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\sin k \cdot \tan k}\\
t_2 := \frac{\sqrt{2}}{\frac{k}{t}}\\
t_3 := \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
t_4 := t\_1 \cdot t\_3\\
\mathbf{if}\;\ell \cdot \ell \leq 0:\\
\;\;\;\;\left(t \cdot \left(\frac{\sqrt{2}}{k} \cdot {\left(t \cdot \left({\left(\sqrt[3]{\ell}\right)}^{-2} \cdot t\_1\right)\right)}^{-2}\right)\right) \cdot \frac{t\_2}{t\_4}\\
\mathbf{elif}\;\ell \cdot \ell \leq 5 \cdot 10^{+243}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_2}{{t\_4}^{2}} \cdot \frac{t\_2}{t\_3 \cdot {\left(\sqrt[3]{t\_1}\right)}^{3}}\\
\end{array}
\end{array}
if (*.f64 l l) < 0.0Initial program 20.2%
*-commutative20.2%
associate-/r*20.2%
Simplified42.0%
add-sqr-sqrt42.0%
add-cube-cbrt42.0%
times-frac42.0%
Applied egg-rr86.6%
Taylor expanded in k around 0 86.7%
div-inv86.7%
associate-/l*86.7%
pow-flip86.6%
div-inv86.6%
pow-flip86.6%
metadata-eval86.6%
metadata-eval86.6%
Applied egg-rr86.6%
associate-*l*86.7%
associate-*l*86.7%
Simplified86.7%
if 0.0 < (*.f64 l l) < 5.00000000000000037e243Initial program 40.8%
*-commutative40.8%
associate-/r*41.1%
Simplified53.8%
+-rgt-identity53.8%
unpow253.8%
clear-num53.8%
un-div-inv53.8%
Applied egg-rr53.8%
add-sqr-sqrt30.6%
pow230.6%
sqrt-div30.6%
sqrt-pow133.9%
metadata-eval33.9%
sqrt-prod19.0%
add-sqr-sqrt33.9%
Applied egg-rr33.9%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt92.1%
associate-*l*92.1%
neg-mul-192.1%
Simplified92.1%
if 5.00000000000000037e243 < (*.f64 l l) Initial program 38.0%
*-commutative38.0%
associate-/r*38.1%
Simplified38.1%
add-sqr-sqrt38.1%
add-cube-cbrt38.1%
times-frac38.1%
Applied egg-rr81.8%
add-cube-cbrt81.9%
pow381.9%
Applied egg-rr81.9%
Final simplification87.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (cbrt (* (sin k) (tan k)))))
(if (or (<= (* l l) 0.0) (not (<= (* l l) 5e+243)))
(*
(* t (* (/ (sqrt 2.0) k) (pow (* t (* (pow (cbrt l) -2.0) t_1)) -2.0)))
(/ (/ (sqrt 2.0) (/ k t)) (* t_1 (/ t (pow (cbrt l) 2.0)))))
(*
-2.0
(/
(/ (* (pow l 2.0) (cos k)) (pow k 2.0))
(* t (- (pow (sin k) 2.0))))))))
double code(double t, double l, double k) {
double t_1 = cbrt((sin(k) * tan(k)));
double tmp;
if (((l * l) <= 0.0) || !((l * l) <= 5e+243)) {
tmp = (t * ((sqrt(2.0) / k) * pow((t * (pow(cbrt(l), -2.0) * t_1)), -2.0))) * ((sqrt(2.0) / (k / t)) / (t_1 * (t / pow(cbrt(l), 2.0))));
} else {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double tmp;
if (((l * l) <= 0.0) || !((l * l) <= 5e+243)) {
tmp = (t * ((Math.sqrt(2.0) / k) * Math.pow((t * (Math.pow(Math.cbrt(l), -2.0) * t_1)), -2.0))) * ((Math.sqrt(2.0) / (k / t)) / (t_1 * (t / Math.pow(Math.cbrt(l), 2.0))));
} else {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(Float64(sin(k) * tan(k))) tmp = 0.0 if ((Float64(l * l) <= 0.0) || !(Float64(l * l) <= 5e+243)) tmp = Float64(Float64(t * Float64(Float64(sqrt(2.0) / k) * (Float64(t * Float64((cbrt(l) ^ -2.0) * t_1)) ^ -2.0))) * Float64(Float64(sqrt(2.0) / Float64(k / t)) / Float64(t_1 * Float64(t / (cbrt(l) ^ 2.0))))); else tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, If[Or[LessEqual[N[(l * l), $MachinePrecision], 0.0], N[Not[LessEqual[N[(l * l), $MachinePrecision], 5e+243]], $MachinePrecision]], N[(N[(t * N[(N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision] * N[Power[N[(t * N[(N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Sqrt[2.0], $MachinePrecision] / N[(k / t), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\sin k \cdot \tan k}\\
\mathbf{if}\;\ell \cdot \ell \leq 0 \lor \neg \left(\ell \cdot \ell \leq 5 \cdot 10^{+243}\right):\\
\;\;\;\;\left(t \cdot \left(\frac{\sqrt{2}}{k} \cdot {\left(t \cdot \left({\left(\sqrt[3]{\ell}\right)}^{-2} \cdot t\_1\right)\right)}^{-2}\right)\right) \cdot \frac{\frac{\sqrt{2}}{\frac{k}{t}}}{t\_1 \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}}\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\end{array}
\end{array}
if (*.f64 l l) < 0.0 or 5.00000000000000037e243 < (*.f64 l l) Initial program 30.1%
*-commutative30.1%
associate-/r*30.1%
Simplified39.8%
add-sqr-sqrt39.8%
add-cube-cbrt39.8%
times-frac39.8%
Applied egg-rr84.0%
Taylor expanded in k around 0 84.0%
div-inv84.0%
associate-/l*84.0%
pow-flip84.0%
div-inv84.0%
pow-flip84.0%
metadata-eval84.0%
metadata-eval84.0%
Applied egg-rr84.0%
associate-*l*82.7%
associate-*l*82.7%
Simplified82.7%
if 0.0 < (*.f64 l l) < 5.00000000000000037e243Initial program 40.8%
*-commutative40.8%
associate-/r*41.1%
Simplified53.8%
+-rgt-identity53.8%
unpow253.8%
clear-num53.8%
un-div-inv53.8%
Applied egg-rr53.8%
add-sqr-sqrt30.6%
pow230.6%
sqrt-div30.6%
sqrt-pow133.9%
metadata-eval33.9%
sqrt-prod19.0%
add-sqr-sqrt33.9%
Applied egg-rr33.9%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt92.1%
associate-*l*92.1%
neg-mul-192.1%
Simplified92.1%
Final simplification87.1%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (cbrt (* (sin k) (tan k))))
(t_2 (/ (sqrt 2.0) (/ k t)))
(t_3 (* t_1 (/ t (pow (cbrt l) 2.0))))
(t_4 (/ t_2 t_3)))
(if (<= (* l l) 0.0)
(*
(* t (* (/ (sqrt 2.0) k) (pow (* t (* (pow (cbrt l) -2.0) t_1)) -2.0)))
t_4)
(if (<= (* l l) 5e+243)
(*
-2.0
(/
(/ (* (pow l 2.0) (cos k)) (pow k 2.0))
(* t (- (pow (sin k) 2.0)))))
(* t_4 (/ t_2 (pow t_3 2.0)))))))
double code(double t, double l, double k) {
double t_1 = cbrt((sin(k) * tan(k)));
double t_2 = sqrt(2.0) / (k / t);
double t_3 = t_1 * (t / pow(cbrt(l), 2.0));
double t_4 = t_2 / t_3;
double tmp;
if ((l * l) <= 0.0) {
tmp = (t * ((sqrt(2.0) / k) * pow((t * (pow(cbrt(l), -2.0) * t_1)), -2.0))) * t_4;
} else if ((l * l) <= 5e+243) {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
} else {
tmp = t_4 * (t_2 / pow(t_3, 2.0));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_2 = Math.sqrt(2.0) / (k / t);
double t_3 = t_1 * (t / Math.pow(Math.cbrt(l), 2.0));
double t_4 = t_2 / t_3;
double tmp;
if ((l * l) <= 0.0) {
tmp = (t * ((Math.sqrt(2.0) / k) * Math.pow((t * (Math.pow(Math.cbrt(l), -2.0) * t_1)), -2.0))) * t_4;
} else if ((l * l) <= 5e+243) {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
} else {
tmp = t_4 * (t_2 / Math.pow(t_3, 2.0));
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(Float64(sin(k) * tan(k))) t_2 = Float64(sqrt(2.0) / Float64(k / t)) t_3 = Float64(t_1 * Float64(t / (cbrt(l) ^ 2.0))) t_4 = Float64(t_2 / t_3) tmp = 0.0 if (Float64(l * l) <= 0.0) tmp = Float64(Float64(t * Float64(Float64(sqrt(2.0) / k) * (Float64(t * Float64((cbrt(l) ^ -2.0) * t_1)) ^ -2.0))) * t_4); elseif (Float64(l * l) <= 5e+243) tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); else tmp = Float64(t_4 * Float64(t_2 / (t_3 ^ 2.0))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[2.0], $MachinePrecision] / N[(k / t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 / t$95$3), $MachinePrecision]}, If[LessEqual[N[(l * l), $MachinePrecision], 0.0], N[(N[(t * N[(N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision] * N[Power[N[(t * N[(N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$4), $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 5e+243], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$4 * N[(t$95$2 / N[Power[t$95$3, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\sin k \cdot \tan k}\\
t_2 := \frac{\sqrt{2}}{\frac{k}{t}}\\
t_3 := t\_1 \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
t_4 := \frac{t\_2}{t\_3}\\
\mathbf{if}\;\ell \cdot \ell \leq 0:\\
\;\;\;\;\left(t \cdot \left(\frac{\sqrt{2}}{k} \cdot {\left(t \cdot \left({\left(\sqrt[3]{\ell}\right)}^{-2} \cdot t\_1\right)\right)}^{-2}\right)\right) \cdot t\_4\\
\mathbf{elif}\;\ell \cdot \ell \leq 5 \cdot 10^{+243}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_4 \cdot \frac{t\_2}{{t\_3}^{2}}\\
\end{array}
\end{array}
if (*.f64 l l) < 0.0Initial program 20.2%
*-commutative20.2%
associate-/r*20.2%
Simplified42.0%
add-sqr-sqrt42.0%
add-cube-cbrt42.0%
times-frac42.0%
Applied egg-rr86.6%
Taylor expanded in k around 0 86.7%
div-inv86.7%
associate-/l*86.7%
pow-flip86.6%
div-inv86.6%
pow-flip86.6%
metadata-eval86.6%
metadata-eval86.6%
Applied egg-rr86.6%
associate-*l*86.7%
associate-*l*86.7%
Simplified86.7%
if 0.0 < (*.f64 l l) < 5.00000000000000037e243Initial program 40.8%
*-commutative40.8%
associate-/r*41.1%
Simplified53.8%
+-rgt-identity53.8%
unpow253.8%
clear-num53.8%
un-div-inv53.8%
Applied egg-rr53.8%
add-sqr-sqrt30.6%
pow230.6%
sqrt-div30.6%
sqrt-pow133.9%
metadata-eval33.9%
sqrt-prod19.0%
add-sqr-sqrt33.9%
Applied egg-rr33.9%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt92.1%
associate-*l*92.1%
neg-mul-192.1%
Simplified92.1%
if 5.00000000000000037e243 < (*.f64 l l) Initial program 38.0%
*-commutative38.0%
associate-/r*38.1%
Simplified38.1%
add-sqr-sqrt38.1%
add-cube-cbrt38.1%
times-frac38.1%
Applied egg-rr81.8%
Final simplification87.8%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* t (pow (cbrt l) -2.0)))
(t_2 (* (cbrt (* (sin k) (tan k))) t_1))
(t_3 (* t (/ (sqrt 2.0) k)))
(t_4 (* (sqrt 2.0) (/ t k))))
(if (<= (* l l) 0.0)
(/ (* (* t_3 (pow t_2 -2.0)) t_4) (* t_1 (cbrt (pow k 2.0))))
(if (<= (* l l) 4e+283)
(*
-2.0
(/
(/ (* (pow l 2.0) (cos k)) (pow k 2.0))
(* t (- (pow (sin k) 2.0)))))
(pow (/ (cbrt (* t_3 t_4)) t_2) 3.0)))))
double code(double t, double l, double k) {
double t_1 = t * pow(cbrt(l), -2.0);
double t_2 = cbrt((sin(k) * tan(k))) * t_1;
double t_3 = t * (sqrt(2.0) / k);
double t_4 = sqrt(2.0) * (t / k);
double tmp;
if ((l * l) <= 0.0) {
tmp = ((t_3 * pow(t_2, -2.0)) * t_4) / (t_1 * cbrt(pow(k, 2.0)));
} else if ((l * l) <= 4e+283) {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
} else {
tmp = pow((cbrt((t_3 * t_4)) / t_2), 3.0);
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = t * Math.pow(Math.cbrt(l), -2.0);
double t_2 = Math.cbrt((Math.sin(k) * Math.tan(k))) * t_1;
double t_3 = t * (Math.sqrt(2.0) / k);
double t_4 = Math.sqrt(2.0) * (t / k);
double tmp;
if ((l * l) <= 0.0) {
tmp = ((t_3 * Math.pow(t_2, -2.0)) * t_4) / (t_1 * Math.cbrt(Math.pow(k, 2.0)));
} else if ((l * l) <= 4e+283) {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
} else {
tmp = Math.pow((Math.cbrt((t_3 * t_4)) / t_2), 3.0);
}
return tmp;
}
function code(t, l, k) t_1 = Float64(t * (cbrt(l) ^ -2.0)) t_2 = Float64(cbrt(Float64(sin(k) * tan(k))) * t_1) t_3 = Float64(t * Float64(sqrt(2.0) / k)) t_4 = Float64(sqrt(2.0) * Float64(t / k)) tmp = 0.0 if (Float64(l * l) <= 0.0) tmp = Float64(Float64(Float64(t_3 * (t_2 ^ -2.0)) * t_4) / Float64(t_1 * cbrt((k ^ 2.0)))); elseif (Float64(l * l) <= 4e+283) tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); else tmp = Float64(cbrt(Float64(t_3 * t_4)) / t_2) ^ 3.0; end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(t * N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[2.0], $MachinePrecision] * N[(t / k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(l * l), $MachinePrecision], 0.0], N[(N[(N[(t$95$3 * N[Power[t$95$2, -2.0], $MachinePrecision]), $MachinePrecision] * t$95$4), $MachinePrecision] / N[(t$95$1 * N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 4e+283], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[Power[N[(t$95$3 * t$95$4), $MachinePrecision], 1/3], $MachinePrecision] / t$95$2), $MachinePrecision], 3.0], $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t_2 := \sqrt[3]{\sin k \cdot \tan k} \cdot t\_1\\
t_3 := t \cdot \frac{\sqrt{2}}{k}\\
t_4 := \sqrt{2} \cdot \frac{t}{k}\\
\mathbf{if}\;\ell \cdot \ell \leq 0:\\
\;\;\;\;\frac{\left(t\_3 \cdot {t\_2}^{-2}\right) \cdot t\_4}{t\_1 \cdot \sqrt[3]{{k}^{2}}}\\
\mathbf{elif}\;\ell \cdot \ell \leq 4 \cdot 10^{+283}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{t\_3 \cdot t\_4}}{t\_2}\right)}^{3}\\
\end{array}
\end{array}
if (*.f64 l l) < 0.0Initial program 20.2%
*-commutative20.2%
associate-/r*20.2%
Simplified42.0%
add-sqr-sqrt42.0%
add-cube-cbrt42.0%
times-frac42.0%
Applied egg-rr86.6%
Taylor expanded in k around 0 86.7%
associate-*r/86.7%
Applied egg-rr86.7%
Taylor expanded in k around 0 86.7%
if 0.0 < (*.f64 l l) < 3.99999999999999982e283Initial program 40.8%
*-commutative40.8%
associate-/r*41.1%
Simplified52.6%
+-rgt-identity52.6%
unpow252.6%
clear-num52.7%
un-div-inv52.6%
Applied egg-rr52.6%
add-sqr-sqrt29.4%
pow229.4%
sqrt-div29.4%
sqrt-pow132.4%
metadata-eval32.4%
sqrt-prod18.9%
add-sqr-sqrt32.4%
Applied egg-rr32.4%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt89.4%
associate-*l*89.4%
neg-mul-189.4%
Simplified89.4%
if 3.99999999999999982e283 < (*.f64 l l) Initial program 37.3%
*-commutative37.3%
associate-/r*37.3%
Simplified37.3%
add-sqr-sqrt37.3%
add-cube-cbrt37.3%
times-frac37.3%
Applied egg-rr83.1%
Taylor expanded in k around 0 83.1%
add-cube-cbrt83.1%
pow383.1%
Applied egg-rr72.3%
Final simplification84.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (cbrt (* (sin k) (tan k)))) (t_2 (/ t (pow (cbrt l) 2.0))))
(if (<= (* l l) 0.0)
(*
(/ (/ (* t (sqrt 2.0)) k) (pow (* t_1 t_2) 2.0))
(/ (/ (sqrt 2.0) (/ k t)) (* t_2 (cbrt (pow k 2.0)))))
(if (<= (* l l) 4e+283)
(*
-2.0
(/
(/ (* (pow l 2.0) (cos k)) (pow k 2.0))
(* t (- (pow (sin k) 2.0)))))
(pow
(/
(cbrt (* (* t (/ (sqrt 2.0) k)) (* (sqrt 2.0) (/ t k))))
(* t_1 (* t (pow (cbrt l) -2.0))))
3.0)))))
double code(double t, double l, double k) {
double t_1 = cbrt((sin(k) * tan(k)));
double t_2 = t / pow(cbrt(l), 2.0);
double tmp;
if ((l * l) <= 0.0) {
tmp = (((t * sqrt(2.0)) / k) / pow((t_1 * t_2), 2.0)) * ((sqrt(2.0) / (k / t)) / (t_2 * cbrt(pow(k, 2.0))));
} else if ((l * l) <= 4e+283) {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
} else {
tmp = pow((cbrt(((t * (sqrt(2.0) / k)) * (sqrt(2.0) * (t / k)))) / (t_1 * (t * pow(cbrt(l), -2.0)))), 3.0);
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_2 = t / Math.pow(Math.cbrt(l), 2.0);
double tmp;
if ((l * l) <= 0.0) {
tmp = (((t * Math.sqrt(2.0)) / k) / Math.pow((t_1 * t_2), 2.0)) * ((Math.sqrt(2.0) / (k / t)) / (t_2 * Math.cbrt(Math.pow(k, 2.0))));
} else if ((l * l) <= 4e+283) {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
} else {
tmp = Math.pow((Math.cbrt(((t * (Math.sqrt(2.0) / k)) * (Math.sqrt(2.0) * (t / k)))) / (t_1 * (t * Math.pow(Math.cbrt(l), -2.0)))), 3.0);
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(Float64(sin(k) * tan(k))) t_2 = Float64(t / (cbrt(l) ^ 2.0)) tmp = 0.0 if (Float64(l * l) <= 0.0) tmp = Float64(Float64(Float64(Float64(t * sqrt(2.0)) / k) / (Float64(t_1 * t_2) ^ 2.0)) * Float64(Float64(sqrt(2.0) / Float64(k / t)) / Float64(t_2 * cbrt((k ^ 2.0))))); elseif (Float64(l * l) <= 4e+283) tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); else tmp = Float64(cbrt(Float64(Float64(t * Float64(sqrt(2.0) / k)) * Float64(sqrt(2.0) * Float64(t / k)))) / Float64(t_1 * Float64(t * (cbrt(l) ^ -2.0)))) ^ 3.0; end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(l * l), $MachinePrecision], 0.0], N[(N[(N[(N[(t * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision] / N[Power[N[(t$95$1 * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Sqrt[2.0], $MachinePrecision] / N[(k / t), $MachinePrecision]), $MachinePrecision] / N[(t$95$2 * N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 4e+283], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[Power[N[(N[(t * N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] * N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(t$95$1 * N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\sin k \cdot \tan k}\\
t_2 := \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
\mathbf{if}\;\ell \cdot \ell \leq 0:\\
\;\;\;\;\frac{\frac{t \cdot \sqrt{2}}{k}}{{\left(t\_1 \cdot t\_2\right)}^{2}} \cdot \frac{\frac{\sqrt{2}}{\frac{k}{t}}}{t\_2 \cdot \sqrt[3]{{k}^{2}}}\\
\mathbf{elif}\;\ell \cdot \ell \leq 4 \cdot 10^{+283}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\left(t \cdot \frac{\sqrt{2}}{k}\right) \cdot \left(\sqrt{2} \cdot \frac{t}{k}\right)}}{t\_1 \cdot \left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)}\right)}^{3}\\
\end{array}
\end{array}
if (*.f64 l l) < 0.0Initial program 20.2%
*-commutative20.2%
associate-/r*20.2%
Simplified42.0%
add-sqr-sqrt42.0%
add-cube-cbrt42.0%
times-frac42.0%
Applied egg-rr86.6%
Taylor expanded in k around 0 86.7%
Taylor expanded in k around 0 86.7%
if 0.0 < (*.f64 l l) < 3.99999999999999982e283Initial program 40.8%
*-commutative40.8%
associate-/r*41.1%
Simplified52.6%
+-rgt-identity52.6%
unpow252.6%
clear-num52.7%
un-div-inv52.6%
Applied egg-rr52.6%
add-sqr-sqrt29.4%
pow229.4%
sqrt-div29.4%
sqrt-pow132.4%
metadata-eval32.4%
sqrt-prod18.9%
add-sqr-sqrt32.4%
Applied egg-rr32.4%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt89.4%
associate-*l*89.4%
neg-mul-189.4%
Simplified89.4%
if 3.99999999999999982e283 < (*.f64 l l) Initial program 37.3%
*-commutative37.3%
associate-/r*37.3%
Simplified37.3%
add-sqr-sqrt37.3%
add-cube-cbrt37.3%
times-frac37.3%
Applied egg-rr83.1%
Taylor expanded in k around 0 83.1%
add-cube-cbrt83.1%
pow383.1%
Applied egg-rr72.3%
Final simplification84.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (cbrt (* (sin k) (tan k))))
(t_2 (/ t (pow (cbrt l) 2.0)))
(t_3 (/ (sqrt 2.0) (/ k t))))
(if (<= (* l l) 0.0)
(* (/ t_3 (pow (* t_1 t_2) 2.0)) (/ t_3 (* t_2 (cbrt (pow k 2.0)))))
(if (<= (* l l) 4e+283)
(*
-2.0
(/
(/ (* (pow l 2.0) (cos k)) (pow k 2.0))
(* t (- (pow (sin k) 2.0)))))
(pow
(/
(cbrt (* (* t (/ (sqrt 2.0) k)) (* (sqrt 2.0) (/ t k))))
(* t_1 (* t (pow (cbrt l) -2.0))))
3.0)))))
double code(double t, double l, double k) {
double t_1 = cbrt((sin(k) * tan(k)));
double t_2 = t / pow(cbrt(l), 2.0);
double t_3 = sqrt(2.0) / (k / t);
double tmp;
if ((l * l) <= 0.0) {
tmp = (t_3 / pow((t_1 * t_2), 2.0)) * (t_3 / (t_2 * cbrt(pow(k, 2.0))));
} else if ((l * l) <= 4e+283) {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
} else {
tmp = pow((cbrt(((t * (sqrt(2.0) / k)) * (sqrt(2.0) * (t / k)))) / (t_1 * (t * pow(cbrt(l), -2.0)))), 3.0);
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.cbrt((Math.sin(k) * Math.tan(k)));
double t_2 = t / Math.pow(Math.cbrt(l), 2.0);
double t_3 = Math.sqrt(2.0) / (k / t);
double tmp;
if ((l * l) <= 0.0) {
tmp = (t_3 / Math.pow((t_1 * t_2), 2.0)) * (t_3 / (t_2 * Math.cbrt(Math.pow(k, 2.0))));
} else if ((l * l) <= 4e+283) {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
} else {
tmp = Math.pow((Math.cbrt(((t * (Math.sqrt(2.0) / k)) * (Math.sqrt(2.0) * (t / k)))) / (t_1 * (t * Math.pow(Math.cbrt(l), -2.0)))), 3.0);
}
return tmp;
}
function code(t, l, k) t_1 = cbrt(Float64(sin(k) * tan(k))) t_2 = Float64(t / (cbrt(l) ^ 2.0)) t_3 = Float64(sqrt(2.0) / Float64(k / t)) tmp = 0.0 if (Float64(l * l) <= 0.0) tmp = Float64(Float64(t_3 / (Float64(t_1 * t_2) ^ 2.0)) * Float64(t_3 / Float64(t_2 * cbrt((k ^ 2.0))))); elseif (Float64(l * l) <= 4e+283) tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); else tmp = Float64(cbrt(Float64(Float64(t * Float64(sqrt(2.0) / k)) * Float64(sqrt(2.0) * Float64(t / k)))) / Float64(t_1 * Float64(t * (cbrt(l) ^ -2.0)))) ^ 3.0; end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[2.0], $MachinePrecision] / N[(k / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(l * l), $MachinePrecision], 0.0], N[(N[(t$95$3 / N[Power[N[(t$95$1 * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(t$95$3 / N[(t$95$2 * N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 4e+283], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[Power[N[(N[(t * N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] * N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(t$95$1 * N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt[3]{\sin k \cdot \tan k}\\
t_2 := \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
t_3 := \frac{\sqrt{2}}{\frac{k}{t}}\\
\mathbf{if}\;\ell \cdot \ell \leq 0:\\
\;\;\;\;\frac{t\_3}{{\left(t\_1 \cdot t\_2\right)}^{2}} \cdot \frac{t\_3}{t\_2 \cdot \sqrt[3]{{k}^{2}}}\\
\mathbf{elif}\;\ell \cdot \ell \leq 4 \cdot 10^{+283}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\left(t \cdot \frac{\sqrt{2}}{k}\right) \cdot \left(\sqrt{2} \cdot \frac{t}{k}\right)}}{t\_1 \cdot \left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)}\right)}^{3}\\
\end{array}
\end{array}
if (*.f64 l l) < 0.0Initial program 20.2%
*-commutative20.2%
associate-/r*20.2%
Simplified42.0%
add-sqr-sqrt42.0%
add-cube-cbrt42.0%
times-frac42.0%
Applied egg-rr86.6%
Taylor expanded in k around 0 86.6%
if 0.0 < (*.f64 l l) < 3.99999999999999982e283Initial program 40.8%
*-commutative40.8%
associate-/r*41.1%
Simplified52.6%
+-rgt-identity52.6%
unpow252.6%
clear-num52.7%
un-div-inv52.6%
Applied egg-rr52.6%
add-sqr-sqrt29.4%
pow229.4%
sqrt-div29.4%
sqrt-pow132.4%
metadata-eval32.4%
sqrt-prod18.9%
add-sqr-sqrt32.4%
Applied egg-rr32.4%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt89.4%
associate-*l*89.4%
neg-mul-189.4%
Simplified89.4%
if 3.99999999999999982e283 < (*.f64 l l) Initial program 37.3%
*-commutative37.3%
associate-/r*37.3%
Simplified37.3%
add-sqr-sqrt37.3%
add-cube-cbrt37.3%
times-frac37.3%
Applied egg-rr83.1%
Taylor expanded in k around 0 83.1%
add-cube-cbrt83.1%
pow383.1%
Applied egg-rr72.3%
Final simplification84.6%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (sin k) 2.0)))
(if (<= t 4.4e-124)
(* (* l l) (/ 2.0 (* (pow k 2.0) (* t (/ t_1 (cos k))))))
(if (<= t 1.35e+140)
(pow
(/
(cbrt (* (* t (/ (sqrt 2.0) k)) (* (sqrt 2.0) (/ t k))))
(* (cbrt (* (sin k) (tan k))) (* t (pow (cbrt l) -2.0))))
3.0)
(* -2.0 (/ (/ (* (pow l 2.0) (cos k)) (pow k 2.0)) (* t_1 (- t))))))))
double code(double t, double l, double k) {
double t_1 = pow(sin(k), 2.0);
double tmp;
if (t <= 4.4e-124) {
tmp = (l * l) * (2.0 / (pow(k, 2.0) * (t * (t_1 / cos(k)))));
} else if (t <= 1.35e+140) {
tmp = pow((cbrt(((t * (sqrt(2.0) / k)) * (sqrt(2.0) * (t / k)))) / (cbrt((sin(k) * tan(k))) * (t * pow(cbrt(l), -2.0)))), 3.0);
} else {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t_1 * -t));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.sin(k), 2.0);
double tmp;
if (t <= 4.4e-124) {
tmp = (l * l) * (2.0 / (Math.pow(k, 2.0) * (t * (t_1 / Math.cos(k)))));
} else if (t <= 1.35e+140) {
tmp = Math.pow((Math.cbrt(((t * (Math.sqrt(2.0) / k)) * (Math.sqrt(2.0) * (t / k)))) / (Math.cbrt((Math.sin(k) * Math.tan(k))) * (t * Math.pow(Math.cbrt(l), -2.0)))), 3.0);
} else {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t_1 * -t));
}
return tmp;
}
function code(t, l, k) t_1 = sin(k) ^ 2.0 tmp = 0.0 if (t <= 4.4e-124) tmp = Float64(Float64(l * l) * Float64(2.0 / Float64((k ^ 2.0) * Float64(t * Float64(t_1 / cos(k)))))); elseif (t <= 1.35e+140) tmp = Float64(cbrt(Float64(Float64(t * Float64(sqrt(2.0) / k)) * Float64(sqrt(2.0) * Float64(t / k)))) / Float64(cbrt(Float64(sin(k) * tan(k))) * Float64(t * (cbrt(l) ^ -2.0)))) ^ 3.0; else tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t_1 * Float64(-t)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[t, 4.4e-124], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[(t$95$1 / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.35e+140], N[Power[N[(N[Power[N[(N[(t * N[(N[Sqrt[2.0], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] * N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / N[(N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * N[(t * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$1 * (-t)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\sin k}^{2}\\
\mathbf{if}\;t \leq 4.4 \cdot 10^{-124}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{k}^{2} \cdot \left(t \cdot \frac{t\_1}{\cos k}\right)}\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{+140}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\left(t \cdot \frac{\sqrt{2}}{k}\right) \cdot \left(\sqrt{2} \cdot \frac{t}{k}\right)}}{\sqrt[3]{\sin k \cdot \tan k} \cdot \left(t \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)}\right)}^{3}\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t\_1 \cdot \left(-t\right)}\\
\end{array}
\end{array}
if t < 4.3999999999999998e-124Initial program 32.6%
Simplified41.0%
add-sqr-sqrt14.8%
pow214.8%
*-commutative14.8%
sqrt-prod6.4%
associate-*r*6.4%
sqrt-prod6.4%
sqrt-pow18.4%
metadata-eval8.4%
pow18.4%
sqrt-pow110.3%
metadata-eval10.3%
Applied egg-rr10.3%
Taylor expanded in t around -inf 0.0%
mul-1-neg0.0%
associate-/l*0.0%
distribute-lft-neg-in0.0%
associate-/l*0.0%
unpow20.0%
rem-square-sqrt73.7%
Simplified73.7%
if 4.3999999999999998e-124 < t < 1.35000000000000009e140Initial program 56.2%
*-commutative56.2%
associate-/r*56.2%
Simplified67.5%
add-sqr-sqrt67.4%
add-cube-cbrt67.3%
times-frac67.4%
Applied egg-rr93.4%
Taylor expanded in k around 0 93.4%
add-cube-cbrt93.3%
pow393.3%
Applied egg-rr89.1%
if 1.35000000000000009e140 < t Initial program 5.9%
*-commutative5.9%
associate-/r*5.9%
Simplified35.3%
+-rgt-identity35.3%
unpow235.3%
clear-num35.3%
un-div-inv35.3%
Applied egg-rr35.3%
add-sqr-sqrt35.3%
pow235.3%
sqrt-div35.3%
sqrt-pow141.5%
metadata-eval41.5%
sqrt-prod17.9%
add-sqr-sqrt44.4%
Applied egg-rr44.4%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt77.6%
associate-*l*77.6%
neg-mul-177.6%
Simplified77.6%
Final simplification78.2%
(FPCore (t l k)
:precision binary64
(if (<=
(*
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))
(+ -1.0 (+ 1.0 (pow (/ k t) 2.0))))
INFINITY)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(* (tan k) (* (sin k) (pow (/ (pow t 1.5) l) 2.0))))
(* (* l l) (* 2.0 (/ (/ (cos k) (pow k 2.0)) (* t (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (((tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))) * (-1.0 + (1.0 + pow((k / t), 2.0)))) <= ((double) INFINITY)) {
tmp = (2.0 / ((k / t) / (t / k))) / (tan(k) * (sin(k) * pow((pow(t, 1.5) / l), 2.0)));
} else {
tmp = (l * l) * (2.0 * ((cos(k) / pow(k, 2.0)) / (t * pow(sin(k), 2.0))));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (((Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))) * (-1.0 + (1.0 + Math.pow((k / t), 2.0)))) <= Double.POSITIVE_INFINITY) {
tmp = (2.0 / ((k / t) / (t / k))) / (Math.tan(k) * (Math.sin(k) * Math.pow((Math.pow(t, 1.5) / l), 2.0)));
} else {
tmp = (l * l) * (2.0 * ((Math.cos(k) / Math.pow(k, 2.0)) / (t * Math.pow(Math.sin(k), 2.0))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if ((math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))) * (-1.0 + (1.0 + math.pow((k / t), 2.0)))) <= math.inf: tmp = (2.0 / ((k / t) / (t / k))) / (math.tan(k) * (math.sin(k) * math.pow((math.pow(t, 1.5) / l), 2.0))) else: tmp = (l * l) * (2.0 * ((math.cos(k) / math.pow(k, 2.0)) / (t * math.pow(math.sin(k), 2.0)))) return tmp
function code(t, l, k) tmp = 0.0 if (Float64(Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))) * Float64(-1.0 + Float64(1.0 + (Float64(k / t) ^ 2.0)))) <= Inf) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(tan(k) * Float64(sin(k) * (Float64((t ^ 1.5) / l) ^ 2.0)))); else tmp = Float64(Float64(l * l) * Float64(2.0 * Float64(Float64(cos(k) / (k ^ 2.0)) / Float64(t * (sin(k) ^ 2.0))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (((tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))) * (-1.0 + (1.0 + ((k / t) ^ 2.0)))) <= Inf) tmp = (2.0 / ((k / t) / (t / k))) / (tan(k) * (sin(k) * (((t ^ 1.5) / l) ^ 2.0))); else tmp = (l * l) * (2.0 * ((cos(k) / (k ^ 2.0)) / (t * (sin(k) ^ 2.0)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(-1.0 + N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 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]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right) \cdot \left(-1 + \left(1 + {\left(\frac{k}{t}\right)}^{2}\right)\right) \leq \infty:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\tan k \cdot \left(\sin k \cdot {\left(\frac{{t}^{1.5}}{\ell}\right)}^{2}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(2 \cdot \frac{\frac{\cos k}{{k}^{2}}}{t \cdot {\sin k}^{2}}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64))) < +inf.0Initial program 82.5%
*-commutative82.5%
associate-/r*82.9%
Simplified88.6%
+-rgt-identity88.6%
unpow288.6%
clear-num88.7%
un-div-inv88.6%
Applied egg-rr88.6%
add-sqr-sqrt48.2%
pow248.2%
sqrt-div48.2%
sqrt-pow150.0%
metadata-eval50.0%
sqrt-prod31.4%
add-sqr-sqrt55.2%
Applied egg-rr55.2%
pow155.2%
*-commutative55.2%
Applied egg-rr55.2%
unpow155.2%
*-commutative55.2%
associate-*l*55.3%
Simplified55.3%
if +inf.0 < (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64))) Initial program 0.0%
Simplified15.9%
Taylor expanded in t around 0 62.4%
associate-/r*62.4%
Simplified62.4%
Final simplification59.4%
(FPCore (t l k)
:precision binary64
(if (or (<= l 7e-170) (not (<= l 1.75e+145)))
(/
(* (/ t k) (* 2.0 (/ t k)))
(pow (* (cbrt (* (sin k) (tan k))) (/ t (pow (cbrt l) 2.0))) 3.0))
(*
-2.0
(/ (/ (* (pow l 2.0) (cos k)) (pow k 2.0)) (* t (- (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if ((l <= 7e-170) || !(l <= 1.75e+145)) {
tmp = ((t / k) * (2.0 * (t / k))) / pow((cbrt((sin(k) * tan(k))) * (t / pow(cbrt(l), 2.0))), 3.0);
} else {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((l <= 7e-170) || !(l <= 1.75e+145)) {
tmp = ((t / k) * (2.0 * (t / k))) / Math.pow((Math.cbrt((Math.sin(k) * Math.tan(k))) * (t / Math.pow(Math.cbrt(l), 2.0))), 3.0);
} else {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((l <= 7e-170) || !(l <= 1.75e+145)) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 * Float64(t / k))) / (Float64(cbrt(Float64(sin(k) * tan(k))) * Float64(t / (cbrt(l) ^ 2.0))) ^ 3.0)); else tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[l, 7e-170], N[Not[LessEqual[l, 1.75e+145]], $MachinePrecision]], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 * N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[(N[Power[N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 7 \cdot 10^{-170} \lor \neg \left(\ell \leq 1.75 \cdot 10^{+145}\right):\\
\;\;\;\;\frac{\frac{t}{k} \cdot \left(2 \cdot \frac{t}{k}\right)}{{\left(\sqrt[3]{\sin k \cdot \tan k} \cdot \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\end{array}
\end{array}
if l < 6.9999999999999997e-170 or 1.7500000000000001e145 < l Initial program 30.3%
*-commutative30.3%
associate-/r*30.3%
Simplified42.3%
+-rgt-identity42.3%
unpow242.3%
clear-num42.3%
un-div-inv42.3%
Applied egg-rr42.3%
add-cube-cbrt42.3%
pow342.3%
cbrt-prod42.3%
cbrt-div42.3%
rem-cbrt-cube54.0%
cbrt-prod67.5%
pow267.5%
Applied egg-rr67.5%
associate-/r/68.1%
Applied egg-rr68.1%
*-commutative68.1%
associate-/r/68.1%
associate-*l/68.1%
associate-*r/68.1%
Simplified68.1%
if 6.9999999999999997e-170 < l < 1.7500000000000001e145Initial program 47.2%
*-commutative47.2%
associate-/r*47.7%
Simplified56.7%
+-rgt-identity56.7%
unpow256.7%
clear-num56.7%
un-div-inv56.7%
Applied egg-rr56.7%
add-sqr-sqrt32.0%
pow232.0%
sqrt-div32.0%
sqrt-pow136.1%
metadata-eval36.1%
sqrt-prod36.1%
add-sqr-sqrt36.1%
Applied egg-rr36.1%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt89.5%
associate-*l*89.5%
neg-mul-189.5%
Simplified89.5%
Final simplification74.2%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ t (pow (cbrt l) 2.0)))
(t_2 (pow (sin k) 2.0))
(t_3 (/ 2.0 (/ (/ k t) (/ t k)))))
(if (<= l 7.6e-170)
(/ t_3 (pow (* t_1 (cbrt (pow k 2.0))) 3.0))
(if (<= l 6.6e+148)
(* -2.0 (/ (/ (* (pow l 2.0) (cos k)) (pow k 2.0)) (* t (- t_2))))
(if (<= l 1e+280)
(/ t_3 (* (* (sin k) (tan k)) (pow t_1 3.0)))
(* (* l l) (* 2.0 (/ (/ (cos k) (pow k 2.0)) (* t t_2)))))))))
double code(double t, double l, double k) {
double t_1 = t / pow(cbrt(l), 2.0);
double t_2 = pow(sin(k), 2.0);
double t_3 = 2.0 / ((k / t) / (t / k));
double tmp;
if (l <= 7.6e-170) {
tmp = t_3 / pow((t_1 * cbrt(pow(k, 2.0))), 3.0);
} else if (l <= 6.6e+148) {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -t_2));
} else if (l <= 1e+280) {
tmp = t_3 / ((sin(k) * tan(k)) * pow(t_1, 3.0));
} else {
tmp = (l * l) * (2.0 * ((cos(k) / pow(k, 2.0)) / (t * t_2)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = t / Math.pow(Math.cbrt(l), 2.0);
double t_2 = Math.pow(Math.sin(k), 2.0);
double t_3 = 2.0 / ((k / t) / (t / k));
double tmp;
if (l <= 7.6e-170) {
tmp = t_3 / Math.pow((t_1 * Math.cbrt(Math.pow(k, 2.0))), 3.0);
} else if (l <= 6.6e+148) {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -t_2));
} else if (l <= 1e+280) {
tmp = t_3 / ((Math.sin(k) * Math.tan(k)) * Math.pow(t_1, 3.0));
} else {
tmp = (l * l) * (2.0 * ((Math.cos(k) / Math.pow(k, 2.0)) / (t * t_2)));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(t / (cbrt(l) ^ 2.0)) t_2 = sin(k) ^ 2.0 t_3 = Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) tmp = 0.0 if (l <= 7.6e-170) tmp = Float64(t_3 / (Float64(t_1 * cbrt((k ^ 2.0))) ^ 3.0)); elseif (l <= 6.6e+148) tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-t_2)))); elseif (l <= 1e+280) tmp = Float64(t_3 / Float64(Float64(sin(k) * tan(k)) * (t_1 ^ 3.0))); else tmp = Float64(Float64(l * l) * Float64(2.0 * Float64(Float64(cos(k) / (k ^ 2.0)) / Float64(t * t_2)))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$3 = N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 7.6e-170], N[(t$95$3 / N[Power[N[(t$95$1 * N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 6.6e+148], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-t$95$2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 1e+280], N[(t$95$3 / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[Power[t$95$1, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
t_2 := {\sin k}^{2}\\
t_3 := \frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}\\
\mathbf{if}\;\ell \leq 7.6 \cdot 10^{-170}:\\
\;\;\;\;\frac{t\_3}{{\left(t\_1 \cdot \sqrt[3]{{k}^{2}}\right)}^{3}}\\
\mathbf{elif}\;\ell \leq 6.6 \cdot 10^{+148}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-t\_2\right)}\\
\mathbf{elif}\;\ell \leq 10^{+280}:\\
\;\;\;\;\frac{t\_3}{\left(\sin k \cdot \tan k\right) \cdot {t\_1}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(2 \cdot \frac{\frac{\cos k}{{k}^{2}}}{t \cdot t\_2}\right)\\
\end{array}
\end{array}
if l < 7.5999999999999995e-170Initial program 29.7%
*-commutative29.7%
associate-/r*29.7%
Simplified44.0%
+-rgt-identity44.0%
unpow244.0%
clear-num44.0%
un-div-inv44.0%
Applied egg-rr44.0%
add-cube-cbrt44.0%
pow344.0%
cbrt-prod44.0%
cbrt-div44.0%
rem-cbrt-cube54.6%
cbrt-prod66.6%
pow266.6%
Applied egg-rr66.6%
Taylor expanded in k around 0 65.1%
if 7.5999999999999995e-170 < l < 6.60000000000000021e148Initial program 47.2%
*-commutative47.2%
associate-/r*47.7%
Simplified56.7%
+-rgt-identity56.7%
unpow256.7%
clear-num56.7%
un-div-inv56.7%
Applied egg-rr56.7%
add-sqr-sqrt32.0%
pow232.0%
sqrt-div32.0%
sqrt-pow136.1%
metadata-eval36.1%
sqrt-prod36.1%
add-sqr-sqrt36.1%
Applied egg-rr36.1%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt89.5%
associate-*l*89.5%
neg-mul-189.5%
Simplified89.5%
if 6.60000000000000021e148 < l < 1e280Initial program 37.8%
*-commutative37.8%
associate-/r*37.8%
Simplified37.8%
+-rgt-identity37.8%
unpow237.8%
clear-num37.8%
un-div-inv37.8%
Applied egg-rr37.8%
add-cube-cbrt37.8%
associate-*l*37.8%
cbrt-div37.8%
rem-cbrt-cube37.8%
cbrt-prod37.8%
pow237.8%
pow237.8%
cbrt-div37.8%
rem-cbrt-cube50.8%
cbrt-prod74.2%
pow274.2%
Applied egg-rr74.2%
unpow274.2%
cube-mult74.1%
Simplified74.1%
if 1e280 < l Initial program 16.7%
Simplified16.7%
Taylor expanded in t around 0 83.3%
associate-/r*84.9%
Simplified84.9%
Final simplification73.4%
(FPCore (t l k)
:precision binary64
(if (<= l 4.1e-170)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (pow k 2.0))) 3.0))
(*
-2.0
(/ (/ (* (pow l 2.0) (cos k)) (pow k 2.0)) (* t (- (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (l <= 4.1e-170) {
tmp = (2.0 / ((k / t) / (t / k))) / pow(((t / pow(cbrt(l), 2.0)) * cbrt(pow(k, 2.0))), 3.0);
} else {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (l <= 4.1e-170) {
tmp = (2.0 / ((k / t) / (t / k))) / Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.pow(k, 2.0))), 3.0);
} else {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (l <= 4.1e-170) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / (Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt((k ^ 2.0))) ^ 3.0)); else tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); end return tmp end
code[t_, l_, k_] := If[LessEqual[l, 4.1e-170], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Power[k, 2.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 4.1 \cdot 10^{-170}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{{k}^{2}}\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\end{array}
\end{array}
if l < 4.09999999999999966e-170Initial program 29.7%
*-commutative29.7%
associate-/r*29.7%
Simplified44.0%
+-rgt-identity44.0%
unpow244.0%
clear-num44.0%
un-div-inv44.0%
Applied egg-rr44.0%
add-cube-cbrt44.0%
pow344.0%
cbrt-prod44.0%
cbrt-div44.0%
rem-cbrt-cube54.6%
cbrt-prod66.6%
pow266.6%
Applied egg-rr66.6%
Taylor expanded in k around 0 65.1%
if 4.09999999999999966e-170 < l Initial program 43.2%
*-commutative43.2%
associate-/r*43.6%
Simplified50.0%
+-rgt-identity50.0%
unpow250.0%
clear-num50.0%
un-div-inv50.0%
Applied egg-rr50.0%
add-sqr-sqrt25.6%
pow225.6%
sqrt-div25.6%
sqrt-pow130.5%
metadata-eval30.5%
sqrt-prod33.3%
add-sqr-sqrt33.4%
Applied egg-rr33.4%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt81.0%
associate-*l*81.0%
neg-mul-181.0%
Simplified81.0%
Final simplification71.5%
(FPCore (t l k)
:precision binary64
(if (<= l 5.8e-170)
(/
(* (/ t k) (* 2.0 (/ t k)))
(* (* (sin k) (tan k)) (pow (/ (pow t 1.5) l) 2.0)))
(*
-2.0
(/ (/ (* (pow l 2.0) (cos k)) (pow k 2.0)) (* t (- (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (l <= 5.8e-170) {
tmp = ((t / k) * (2.0 * (t / k))) / ((sin(k) * tan(k)) * pow((pow(t, 1.5) / l), 2.0));
} else {
tmp = -2.0 * (((pow(l, 2.0) * cos(k)) / pow(k, 2.0)) / (t * -pow(sin(k), 2.0)));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (l <= 5.8d-170) then
tmp = ((t / k) * (2.0d0 * (t / k))) / ((sin(k) * tan(k)) * (((t ** 1.5d0) / l) ** 2.0d0))
else
tmp = (-2.0d0) * ((((l ** 2.0d0) * cos(k)) / (k ** 2.0d0)) / (t * -(sin(k) ** 2.0d0)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (l <= 5.8e-170) {
tmp = ((t / k) * (2.0 * (t / k))) / ((Math.sin(k) * Math.tan(k)) * Math.pow((Math.pow(t, 1.5) / l), 2.0));
} else {
tmp = -2.0 * (((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(k, 2.0)) / (t * -Math.pow(Math.sin(k), 2.0)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if l <= 5.8e-170: tmp = ((t / k) * (2.0 * (t / k))) / ((math.sin(k) * math.tan(k)) * math.pow((math.pow(t, 1.5) / l), 2.0)) else: tmp = -2.0 * (((math.pow(l, 2.0) * math.cos(k)) / math.pow(k, 2.0)) / (t * -math.pow(math.sin(k), 2.0))) return tmp
function code(t, l, k) tmp = 0.0 if (l <= 5.8e-170) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 * Float64(t / k))) / Float64(Float64(sin(k) * tan(k)) * (Float64((t ^ 1.5) / l) ^ 2.0))); else tmp = Float64(-2.0 * Float64(Float64(Float64((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / Float64(t * Float64(-(sin(k) ^ 2.0))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (l <= 5.8e-170) tmp = ((t / k) * (2.0 * (t / k))) / ((sin(k) * tan(k)) * (((t ^ 1.5) / l) ^ 2.0)); else tmp = -2.0 * ((((l ^ 2.0) * cos(k)) / (k ^ 2.0)) / (t * -(sin(k) ^ 2.0))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[l, 5.8e-170], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 * N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[Power[t, 1.5], $MachinePrecision] / l), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-2.0 * N[(N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * (-N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 5.8 \cdot 10^{-170}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \left(2 \cdot \frac{t}{k}\right)}{\left(\sin k \cdot \tan k\right) \cdot {\left(\frac{{t}^{1.5}}{\ell}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;-2 \cdot \frac{\frac{{\ell}^{2} \cdot \cos k}{{k}^{2}}}{t \cdot \left(-{\sin k}^{2}\right)}\\
\end{array}
\end{array}
if l < 5.8000000000000001e-170Initial program 29.7%
*-commutative29.7%
associate-/r*29.7%
Simplified44.0%
+-rgt-identity44.0%
unpow244.0%
clear-num44.0%
un-div-inv44.0%
Applied egg-rr44.0%
add-sqr-sqrt26.3%
pow226.3%
sqrt-div26.3%
sqrt-pow129.6%
metadata-eval29.6%
sqrt-prod7.2%
add-sqr-sqrt35.9%
Applied egg-rr35.9%
associate-/r/67.2%
Applied egg-rr35.9%
*-commutative67.2%
associate-/r/67.2%
associate-*l/67.2%
associate-*r/67.2%
Simplified35.9%
if 5.8000000000000001e-170 < l Initial program 43.2%
*-commutative43.2%
associate-/r*43.6%
Simplified50.0%
+-rgt-identity50.0%
unpow250.0%
clear-num50.0%
un-div-inv50.0%
Applied egg-rr50.0%
add-sqr-sqrt25.6%
pow225.6%
sqrt-div25.6%
sqrt-pow130.5%
metadata-eval30.5%
sqrt-prod33.3%
add-sqr-sqrt33.4%
Applied egg-rr33.4%
Taylor expanded in t around -inf 0.0%
associate-/r*0.0%
*-commutative0.0%
unpow20.0%
rem-square-sqrt81.0%
associate-*l*81.0%
neg-mul-181.0%
Simplified81.0%
Final simplification54.1%
(FPCore (t l k)
:precision binary64
(if (or (<= t 8.6e-132) (not (<= t 1.25e+140)))
(* (* l l) (* 2.0 (/ (/ (cos k) (pow k 2.0)) (* t (pow (sin k) 2.0)))))
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(* (* (sin k) (tan k)) (* (/ (pow t 2.0) l) (/ t l))))))
double code(double t, double l, double k) {
double tmp;
if ((t <= 8.6e-132) || !(t <= 1.25e+140)) {
tmp = (l * l) * (2.0 * ((cos(k) / pow(k, 2.0)) / (t * pow(sin(k), 2.0))));
} else {
tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * ((pow(t, 2.0) / l) * (t / l)));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((t <= 8.6d-132) .or. (.not. (t <= 1.25d+140))) then
tmp = (l * l) * (2.0d0 * ((cos(k) / (k ** 2.0d0)) / (t * (sin(k) ** 2.0d0))))
else
tmp = (2.0d0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ** 2.0d0) / l) * (t / l)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= 8.6e-132) || !(t <= 1.25e+140)) {
tmp = (l * l) * (2.0 * ((Math.cos(k) / Math.pow(k, 2.0)) / (t * Math.pow(Math.sin(k), 2.0))));
} else {
tmp = (2.0 / ((k / t) / (t / k))) / ((Math.sin(k) * Math.tan(k)) * ((Math.pow(t, 2.0) / l) * (t / l)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= 8.6e-132) or not (t <= 1.25e+140): tmp = (l * l) * (2.0 * ((math.cos(k) / math.pow(k, 2.0)) / (t * math.pow(math.sin(k), 2.0)))) else: tmp = (2.0 / ((k / t) / (t / k))) / ((math.sin(k) * math.tan(k)) * ((math.pow(t, 2.0) / l) * (t / l))) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= 8.6e-132) || !(t <= 1.25e+140)) tmp = Float64(Float64(l * l) * Float64(2.0 * Float64(Float64(cos(k) / (k ^ 2.0)) / Float64(t * (sin(k) ^ 2.0))))); else tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(Float64(sin(k) * tan(k)) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= 8.6e-132) || ~((t <= 1.25e+140))) tmp = (l * l) * (2.0 * ((cos(k) / (k ^ 2.0)) / (t * (sin(k) ^ 2.0)))); else tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ^ 2.0) / l) * (t / l))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, 8.6e-132], N[Not[LessEqual[t, 1.25e+140]], $MachinePrecision]], N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 8.6 \cdot 10^{-132} \lor \neg \left(t \leq 1.25 \cdot 10^{+140}\right):\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(2 \cdot \frac{\frac{\cos k}{{k}^{2}}}{t \cdot {\sin k}^{2}}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\left(\sin k \cdot \tan k\right) \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)}\\
\end{array}
\end{array}
if t < 8.5999999999999994e-132 or 1.25000000000000002e140 < t Initial program 27.7%
Simplified40.1%
Taylor expanded in t around 0 74.4%
associate-/r*74.5%
Simplified74.5%
if 8.5999999999999994e-132 < t < 1.25000000000000002e140Initial program 55.3%
*-commutative55.3%
associate-/r*55.3%
Simplified66.1%
+-rgt-identity66.1%
unpow266.1%
clear-num66.1%
un-div-inv66.1%
Applied egg-rr66.1%
unpow366.1%
times-frac85.9%
pow285.9%
Applied egg-rr85.9%
Final simplification77.5%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (sin k) 2.0)))
(if (<= t 7.6e-131)
(* (* l l) (/ 2.0 (* (pow k 2.0) (* t (/ t_1 (cos k))))))
(if (<= t 1.4e+140)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(* (* (sin k) (tan k)) (* (/ (pow t 2.0) l) (/ t l))))
(* (* l l) (* 2.0 (/ (/ (cos k) (pow k 2.0)) (* t t_1))))))))
double code(double t, double l, double k) {
double t_1 = pow(sin(k), 2.0);
double tmp;
if (t <= 7.6e-131) {
tmp = (l * l) * (2.0 / (pow(k, 2.0) * (t * (t_1 / cos(k)))));
} else if (t <= 1.4e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * ((pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 * ((cos(k) / pow(k, 2.0)) / (t * t_1)));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: t_1
real(8) :: tmp
t_1 = sin(k) ** 2.0d0
if (t <= 7.6d-131) then
tmp = (l * l) * (2.0d0 / ((k ** 2.0d0) * (t * (t_1 / cos(k)))))
else if (t <= 1.4d+140) then
tmp = (2.0d0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ** 2.0d0) / l) * (t / l)))
else
tmp = (l * l) * (2.0d0 * ((cos(k) / (k ** 2.0d0)) / (t * t_1)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.sin(k), 2.0);
double tmp;
if (t <= 7.6e-131) {
tmp = (l * l) * (2.0 / (Math.pow(k, 2.0) * (t * (t_1 / Math.cos(k)))));
} else if (t <= 1.4e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((Math.sin(k) * Math.tan(k)) * ((Math.pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 * ((Math.cos(k) / Math.pow(k, 2.0)) / (t * t_1)));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow(math.sin(k), 2.0) tmp = 0 if t <= 7.6e-131: tmp = (l * l) * (2.0 / (math.pow(k, 2.0) * (t * (t_1 / math.cos(k))))) elif t <= 1.4e+140: tmp = (2.0 / ((k / t) / (t / k))) / ((math.sin(k) * math.tan(k)) * ((math.pow(t, 2.0) / l) * (t / l))) else: tmp = (l * l) * (2.0 * ((math.cos(k) / math.pow(k, 2.0)) / (t * t_1))) return tmp
function code(t, l, k) t_1 = sin(k) ^ 2.0 tmp = 0.0 if (t <= 7.6e-131) tmp = Float64(Float64(l * l) * Float64(2.0 / Float64((k ^ 2.0) * Float64(t * Float64(t_1 / cos(k)))))); elseif (t <= 1.4e+140) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(Float64(sin(k) * tan(k)) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))); else tmp = Float64(Float64(l * l) * Float64(2.0 * Float64(Float64(cos(k) / (k ^ 2.0)) / Float64(t * t_1)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = sin(k) ^ 2.0; tmp = 0.0; if (t <= 7.6e-131) tmp = (l * l) * (2.0 / ((k ^ 2.0) * (t * (t_1 / cos(k))))); elseif (t <= 1.4e+140) tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ^ 2.0) / l) * (t / l))); else tmp = (l * l) * (2.0 * ((cos(k) / (k ^ 2.0)) / (t * t_1))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[t, 7.6e-131], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t * N[(t$95$1 / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.4e+140], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\sin k}^{2}\\
\mathbf{if}\;t \leq 7.6 \cdot 10^{-131}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{k}^{2} \cdot \left(t \cdot \frac{t\_1}{\cos k}\right)}\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{+140}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\left(\sin k \cdot \tan k\right) \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(2 \cdot \frac{\frac{\cos k}{{k}^{2}}}{t \cdot t\_1}\right)\\
\end{array}
\end{array}
if t < 7.59999999999999989e-131Initial program 32.6%
Simplified41.1%
add-sqr-sqrt14.5%
pow214.5%
*-commutative14.5%
sqrt-prod5.9%
associate-*r*5.9%
sqrt-prod5.9%
sqrt-pow17.9%
metadata-eval7.9%
pow17.9%
sqrt-pow19.2%
metadata-eval9.2%
Applied egg-rr9.2%
Taylor expanded in t around -inf 0.0%
mul-1-neg0.0%
associate-/l*0.0%
distribute-lft-neg-in0.0%
associate-/l*0.0%
unpow20.0%
rem-square-sqrt73.2%
Simplified73.2%
if 7.59999999999999989e-131 < t < 1.39999999999999991e140Initial program 55.3%
*-commutative55.3%
associate-/r*55.3%
Simplified66.1%
+-rgt-identity66.1%
unpow266.1%
clear-num66.1%
un-div-inv66.1%
Applied egg-rr66.1%
unpow366.1%
times-frac85.9%
pow285.9%
Applied egg-rr85.9%
if 1.39999999999999991e140 < t Initial program 5.9%
Simplified35.4%
Taylor expanded in t around 0 79.6%
associate-/r*79.7%
Simplified79.7%
Final simplification77.5%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (sin k) 2.0)))
(if (<= t 2.1e-132)
(* (* l l) (* (cos k) (/ 2.0 (* t_1 (* t (pow k 2.0))))))
(if (<= t 1.45e+140)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(* (* (sin k) (tan k)) (* (/ (pow t 2.0) l) (/ t l))))
(* (* l l) (* 2.0 (/ (/ (cos k) (pow k 2.0)) (* t t_1))))))))
double code(double t, double l, double k) {
double t_1 = pow(sin(k), 2.0);
double tmp;
if (t <= 2.1e-132) {
tmp = (l * l) * (cos(k) * (2.0 / (t_1 * (t * pow(k, 2.0)))));
} else if (t <= 1.45e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * ((pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 * ((cos(k) / pow(k, 2.0)) / (t * t_1)));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: t_1
real(8) :: tmp
t_1 = sin(k) ** 2.0d0
if (t <= 2.1d-132) then
tmp = (l * l) * (cos(k) * (2.0d0 / (t_1 * (t * (k ** 2.0d0)))))
else if (t <= 1.45d+140) then
tmp = (2.0d0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ** 2.0d0) / l) * (t / l)))
else
tmp = (l * l) * (2.0d0 * ((cos(k) / (k ** 2.0d0)) / (t * t_1)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.sin(k), 2.0);
double tmp;
if (t <= 2.1e-132) {
tmp = (l * l) * (Math.cos(k) * (2.0 / (t_1 * (t * Math.pow(k, 2.0)))));
} else if (t <= 1.45e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((Math.sin(k) * Math.tan(k)) * ((Math.pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 * ((Math.cos(k) / Math.pow(k, 2.0)) / (t * t_1)));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow(math.sin(k), 2.0) tmp = 0 if t <= 2.1e-132: tmp = (l * l) * (math.cos(k) * (2.0 / (t_1 * (t * math.pow(k, 2.0))))) elif t <= 1.45e+140: tmp = (2.0 / ((k / t) / (t / k))) / ((math.sin(k) * math.tan(k)) * ((math.pow(t, 2.0) / l) * (t / l))) else: tmp = (l * l) * (2.0 * ((math.cos(k) / math.pow(k, 2.0)) / (t * t_1))) return tmp
function code(t, l, k) t_1 = sin(k) ^ 2.0 tmp = 0.0 if (t <= 2.1e-132) tmp = Float64(Float64(l * l) * Float64(cos(k) * Float64(2.0 / Float64(t_1 * Float64(t * (k ^ 2.0)))))); elseif (t <= 1.45e+140) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(Float64(sin(k) * tan(k)) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))); else tmp = Float64(Float64(l * l) * Float64(2.0 * Float64(Float64(cos(k) / (k ^ 2.0)) / Float64(t * t_1)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = sin(k) ^ 2.0; tmp = 0.0; if (t <= 2.1e-132) tmp = (l * l) * (cos(k) * (2.0 / (t_1 * (t * (k ^ 2.0))))); elseif (t <= 1.45e+140) tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ^ 2.0) / l) * (t / l))); else tmp = (l * l) * (2.0 * ((cos(k) / (k ^ 2.0)) / (t * t_1))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[t, 2.1e-132], N[(N[(l * l), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] * N[(2.0 / N[(t$95$1 * N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.45e+140], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\sin k}^{2}\\
\mathbf{if}\;t \leq 2.1 \cdot 10^{-132}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(\cos k \cdot \frac{2}{t\_1 \cdot \left(t \cdot {k}^{2}\right)}\right)\\
\mathbf{elif}\;t \leq 1.45 \cdot 10^{+140}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\left(\sin k \cdot \tan k\right) \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(2 \cdot \frac{\frac{\cos k}{{k}^{2}}}{t \cdot t\_1}\right)\\
\end{array}
\end{array}
if t < 2.1000000000000001e-132Initial program 32.6%
Simplified41.1%
add-sqr-sqrt14.5%
pow214.5%
*-commutative14.5%
sqrt-prod5.9%
associate-*r*5.9%
sqrt-prod5.9%
sqrt-pow17.9%
metadata-eval7.9%
pow17.9%
sqrt-pow19.2%
metadata-eval9.2%
Applied egg-rr9.2%
Taylor expanded in k around inf 73.2%
*-commutative73.2%
associate-*l/73.2%
associate-/l*73.2%
associate-*r*73.2%
Simplified73.2%
if 2.1000000000000001e-132 < t < 1.4499999999999999e140Initial program 55.3%
*-commutative55.3%
associate-/r*55.3%
Simplified66.1%
+-rgt-identity66.1%
unpow266.1%
clear-num66.1%
un-div-inv66.1%
Applied egg-rr66.1%
unpow366.1%
times-frac85.9%
pow285.9%
Applied egg-rr85.9%
if 1.4499999999999999e140 < t Initial program 5.9%
Simplified35.4%
Taylor expanded in t around 0 79.6%
associate-/r*79.7%
Simplified79.7%
Final simplification77.5%
(FPCore (t l k)
:precision binary64
(if (<= l 6.5e-170)
(/
(* (/ t k) (* 2.0 (/ t k)))
(* (* (sin k) (tan k)) (pow (/ (pow t 1.5) l) 2.0)))
(* (* l l) (* 2.0 (/ (/ (cos k) (pow k 2.0)) (* t (pow (sin k) 2.0)))))))
double code(double t, double l, double k) {
double tmp;
if (l <= 6.5e-170) {
tmp = ((t / k) * (2.0 * (t / k))) / ((sin(k) * tan(k)) * pow((pow(t, 1.5) / l), 2.0));
} else {
tmp = (l * l) * (2.0 * ((cos(k) / pow(k, 2.0)) / (t * pow(sin(k), 2.0))));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (l <= 6.5d-170) then
tmp = ((t / k) * (2.0d0 * (t / k))) / ((sin(k) * tan(k)) * (((t ** 1.5d0) / l) ** 2.0d0))
else
tmp = (l * l) * (2.0d0 * ((cos(k) / (k ** 2.0d0)) / (t * (sin(k) ** 2.0d0))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (l <= 6.5e-170) {
tmp = ((t / k) * (2.0 * (t / k))) / ((Math.sin(k) * Math.tan(k)) * Math.pow((Math.pow(t, 1.5) / l), 2.0));
} else {
tmp = (l * l) * (2.0 * ((Math.cos(k) / Math.pow(k, 2.0)) / (t * Math.pow(Math.sin(k), 2.0))));
}
return tmp;
}
def code(t, l, k): tmp = 0 if l <= 6.5e-170: tmp = ((t / k) * (2.0 * (t / k))) / ((math.sin(k) * math.tan(k)) * math.pow((math.pow(t, 1.5) / l), 2.0)) else: tmp = (l * l) * (2.0 * ((math.cos(k) / math.pow(k, 2.0)) / (t * math.pow(math.sin(k), 2.0)))) return tmp
function code(t, l, k) tmp = 0.0 if (l <= 6.5e-170) tmp = Float64(Float64(Float64(t / k) * Float64(2.0 * Float64(t / k))) / Float64(Float64(sin(k) * tan(k)) * (Float64((t ^ 1.5) / l) ^ 2.0))); else tmp = Float64(Float64(l * l) * Float64(2.0 * Float64(Float64(cos(k) / (k ^ 2.0)) / Float64(t * (sin(k) ^ 2.0))))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (l <= 6.5e-170) tmp = ((t / k) * (2.0 * (t / k))) / ((sin(k) * tan(k)) * (((t ^ 1.5) / l) ^ 2.0)); else tmp = (l * l) * (2.0 * ((cos(k) / (k ^ 2.0)) / (t * (sin(k) ^ 2.0)))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[l, 6.5e-170], N[(N[(N[(t / k), $MachinePrecision] * N[(2.0 * N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[Power[t, 1.5], $MachinePrecision] / l), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 6.5 \cdot 10^{-170}:\\
\;\;\;\;\frac{\frac{t}{k} \cdot \left(2 \cdot \frac{t}{k}\right)}{\left(\sin k \cdot \tan k\right) \cdot {\left(\frac{{t}^{1.5}}{\ell}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left(2 \cdot \frac{\frac{\cos k}{{k}^{2}}}{t \cdot {\sin k}^{2}}\right)\\
\end{array}
\end{array}
if l < 6.50000000000000035e-170Initial program 29.7%
*-commutative29.7%
associate-/r*29.7%
Simplified44.0%
+-rgt-identity44.0%
unpow244.0%
clear-num44.0%
un-div-inv44.0%
Applied egg-rr44.0%
add-sqr-sqrt26.3%
pow226.3%
sqrt-div26.3%
sqrt-pow129.6%
metadata-eval29.6%
sqrt-prod7.2%
add-sqr-sqrt35.9%
Applied egg-rr35.9%
associate-/r/67.2%
Applied egg-rr35.9%
*-commutative67.2%
associate-/r/67.2%
associate-*l/67.2%
associate-*r/67.2%
Simplified35.9%
if 6.50000000000000035e-170 < l Initial program 43.2%
Simplified50.4%
Taylor expanded in t around 0 79.6%
associate-/r*79.7%
Simplified79.7%
Final simplification53.5%
(FPCore (t l k)
:precision binary64
(if (<= t 1.42e-152)
(* (* l l) (/ 2.0 (pow (* k (* (sin k) (sqrt (/ t (cos k))))) 2.0)))
(if (<= t 1.55e+140)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(* (* (sin k) (tan k)) (* (/ (pow t 2.0) l) (/ t l))))
(* (* l l) (/ 2.0 (pow (* (pow k 2.0) (sqrt t)) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 1.42e-152) {
tmp = (l * l) * (2.0 / pow((k * (sin(k) * sqrt((t / cos(k))))), 2.0));
} else if (t <= 1.55e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * ((pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 / pow((pow(k, 2.0) * sqrt(t)), 2.0));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 1.42d-152) then
tmp = (l * l) * (2.0d0 / ((k * (sin(k) * sqrt((t / cos(k))))) ** 2.0d0))
else if (t <= 1.55d+140) then
tmp = (2.0d0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ** 2.0d0) / l) * (t / l)))
else
tmp = (l * l) * (2.0d0 / (((k ** 2.0d0) * sqrt(t)) ** 2.0d0))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 1.42e-152) {
tmp = (l * l) * (2.0 / Math.pow((k * (Math.sin(k) * Math.sqrt((t / Math.cos(k))))), 2.0));
} else if (t <= 1.55e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((Math.sin(k) * Math.tan(k)) * ((Math.pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 / Math.pow((Math.pow(k, 2.0) * Math.sqrt(t)), 2.0));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 1.42e-152: tmp = (l * l) * (2.0 / math.pow((k * (math.sin(k) * math.sqrt((t / math.cos(k))))), 2.0)) elif t <= 1.55e+140: tmp = (2.0 / ((k / t) / (t / k))) / ((math.sin(k) * math.tan(k)) * ((math.pow(t, 2.0) / l) * (t / l))) else: tmp = (l * l) * (2.0 / math.pow((math.pow(k, 2.0) * math.sqrt(t)), 2.0)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 1.42e-152) tmp = Float64(Float64(l * l) * Float64(2.0 / (Float64(k * Float64(sin(k) * sqrt(Float64(t / cos(k))))) ^ 2.0))); elseif (t <= 1.55e+140) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(Float64(sin(k) * tan(k)) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))); else tmp = Float64(Float64(l * l) * Float64(2.0 / (Float64((k ^ 2.0) * sqrt(t)) ^ 2.0))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 1.42e-152) tmp = (l * l) * (2.0 / ((k * (sin(k) * sqrt((t / cos(k))))) ^ 2.0)); elseif (t <= 1.55e+140) tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ^ 2.0) / l) * (t / l))); else tmp = (l * l) * (2.0 / (((k ^ 2.0) * sqrt(t)) ^ 2.0)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 1.42e-152], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(k * N[(N[Sin[k], $MachinePrecision] * N[Sqrt[N[(t / N[Cos[k], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.55e+140], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k, 2.0], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 1.42 \cdot 10^{-152}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left(k \cdot \left(\sin k \cdot \sqrt{\frac{t}{\cos k}}\right)\right)}^{2}}\\
\mathbf{elif}\;t \leq 1.55 \cdot 10^{+140}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\left(\sin k \cdot \tan k\right) \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left({k}^{2} \cdot \sqrt{t}\right)}^{2}}\\
\end{array}
\end{array}
if t < 1.42e-152Initial program 33.4%
Simplified42.2%
add-sqr-sqrt14.8%
pow214.8%
*-commutative14.8%
sqrt-prod6.0%
associate-*r*6.0%
sqrt-prod6.0%
sqrt-pow18.1%
metadata-eval8.1%
pow18.1%
sqrt-pow19.4%
metadata-eval9.4%
Applied egg-rr9.4%
Taylor expanded in k around inf 29.6%
associate-*l*29.6%
Simplified29.6%
if 1.42e-152 < t < 1.55e140Initial program 52.2%
*-commutative52.2%
associate-/r*52.3%
Simplified62.5%
+-rgt-identity62.5%
unpow262.5%
clear-num62.5%
un-div-inv62.5%
Applied egg-rr62.5%
unpow362.4%
times-frac82.5%
pow282.5%
Applied egg-rr82.5%
if 1.55e140 < t Initial program 5.9%
Simplified35.4%
add-sqr-sqrt20.6%
pow220.6%
*-commutative20.6%
sqrt-prod20.6%
associate-*r*20.6%
sqrt-prod23.5%
sqrt-pow126.5%
metadata-eval26.5%
pow126.5%
sqrt-pow138.3%
metadata-eval38.3%
Applied egg-rr38.3%
Taylor expanded in k around 0 76.8%
Final simplification50.9%
(FPCore (t l k)
:precision binary64
(if (<= t 9.5e-132)
(* (* l l) (/ 2.0 (* t (pow k 4.0))))
(if (<= t 1.25e+140)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(* (* (sin k) (tan k)) (* (/ (pow t 2.0) l) (/ t l))))
(* (* l l) (/ 2.0 (pow (* (pow k 2.0) (sqrt t)) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 9.5e-132) {
tmp = (l * l) * (2.0 / (t * pow(k, 4.0)));
} else if (t <= 1.25e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * ((pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 / pow((pow(k, 2.0) * sqrt(t)), 2.0));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 9.5d-132) then
tmp = (l * l) * (2.0d0 / (t * (k ** 4.0d0)))
else if (t <= 1.25d+140) then
tmp = (2.0d0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ** 2.0d0) / l) * (t / l)))
else
tmp = (l * l) * (2.0d0 / (((k ** 2.0d0) * sqrt(t)) ** 2.0d0))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 9.5e-132) {
tmp = (l * l) * (2.0 / (t * Math.pow(k, 4.0)));
} else if (t <= 1.25e+140) {
tmp = (2.0 / ((k / t) / (t / k))) / ((Math.sin(k) * Math.tan(k)) * ((Math.pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 / Math.pow((Math.pow(k, 2.0) * Math.sqrt(t)), 2.0));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 9.5e-132: tmp = (l * l) * (2.0 / (t * math.pow(k, 4.0))) elif t <= 1.25e+140: tmp = (2.0 / ((k / t) / (t / k))) / ((math.sin(k) * math.tan(k)) * ((math.pow(t, 2.0) / l) * (t / l))) else: tmp = (l * l) * (2.0 / math.pow((math.pow(k, 2.0) * math.sqrt(t)), 2.0)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 9.5e-132) tmp = Float64(Float64(l * l) * Float64(2.0 / Float64(t * (k ^ 4.0)))); elseif (t <= 1.25e+140) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(Float64(sin(k) * tan(k)) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))); else tmp = Float64(Float64(l * l) * Float64(2.0 / (Float64((k ^ 2.0) * sqrt(t)) ^ 2.0))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 9.5e-132) tmp = (l * l) * (2.0 / (t * (k ^ 4.0))); elseif (t <= 1.25e+140) tmp = (2.0 / ((k / t) / (t / k))) / ((sin(k) * tan(k)) * (((t ^ 2.0) / l) * (t / l))); else tmp = (l * l) * (2.0 / (((k ^ 2.0) * sqrt(t)) ^ 2.0)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 9.5e-132], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(t * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e+140], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k, 2.0], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 9.5 \cdot 10^{-132}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{t \cdot {k}^{4}}\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{+140}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\left(\sin k \cdot \tan k\right) \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left({k}^{2} \cdot \sqrt{t}\right)}^{2}}\\
\end{array}
\end{array}
if t < 9.49999999999999987e-132Initial program 32.6%
Simplified41.1%
Taylor expanded in k around 0 60.7%
if 9.49999999999999987e-132 < t < 1.25000000000000002e140Initial program 55.3%
*-commutative55.3%
associate-/r*55.3%
Simplified66.1%
+-rgt-identity66.1%
unpow266.1%
clear-num66.1%
un-div-inv66.1%
Applied egg-rr66.1%
unpow366.1%
times-frac85.9%
pow285.9%
Applied egg-rr85.9%
if 1.25000000000000002e140 < t Initial program 5.9%
Simplified35.4%
add-sqr-sqrt20.6%
pow220.6%
*-commutative20.6%
sqrt-prod20.6%
associate-*r*20.6%
sqrt-prod23.5%
sqrt-pow126.5%
metadata-eval26.5%
pow126.5%
sqrt-pow138.3%
metadata-eval38.3%
Applied egg-rr38.3%
Taylor expanded in k around 0 76.8%
Final simplification69.6%
(FPCore (t l k)
:precision binary64
(if (<= t 3.7e-132)
(* (* l l) (/ 2.0 (* t (pow k 4.0))))
(if (<= t 1.45e+140)
(/
(/ 2.0 (* (/ k t) (/ k t)))
(* (* (sin k) (tan k)) (* (/ (pow t 2.0) l) (/ t l))))
(* (* l l) (/ 2.0 (pow (* (pow k 2.0) (sqrt t)) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 3.7e-132) {
tmp = (l * l) * (2.0 / (t * pow(k, 4.0)));
} else if (t <= 1.45e+140) {
tmp = (2.0 / ((k / t) * (k / t))) / ((sin(k) * tan(k)) * ((pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 / pow((pow(k, 2.0) * sqrt(t)), 2.0));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 3.7d-132) then
tmp = (l * l) * (2.0d0 / (t * (k ** 4.0d0)))
else if (t <= 1.45d+140) then
tmp = (2.0d0 / ((k / t) * (k / t))) / ((sin(k) * tan(k)) * (((t ** 2.0d0) / l) * (t / l)))
else
tmp = (l * l) * (2.0d0 / (((k ** 2.0d0) * sqrt(t)) ** 2.0d0))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 3.7e-132) {
tmp = (l * l) * (2.0 / (t * Math.pow(k, 4.0)));
} else if (t <= 1.45e+140) {
tmp = (2.0 / ((k / t) * (k / t))) / ((Math.sin(k) * Math.tan(k)) * ((Math.pow(t, 2.0) / l) * (t / l)));
} else {
tmp = (l * l) * (2.0 / Math.pow((Math.pow(k, 2.0) * Math.sqrt(t)), 2.0));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 3.7e-132: tmp = (l * l) * (2.0 / (t * math.pow(k, 4.0))) elif t <= 1.45e+140: tmp = (2.0 / ((k / t) * (k / t))) / ((math.sin(k) * math.tan(k)) * ((math.pow(t, 2.0) / l) * (t / l))) else: tmp = (l * l) * (2.0 / math.pow((math.pow(k, 2.0) * math.sqrt(t)), 2.0)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 3.7e-132) tmp = Float64(Float64(l * l) * Float64(2.0 / Float64(t * (k ^ 4.0)))); elseif (t <= 1.45e+140) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) * Float64(k / t))) / Float64(Float64(sin(k) * tan(k)) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))); else tmp = Float64(Float64(l * l) * Float64(2.0 / (Float64((k ^ 2.0) * sqrt(t)) ^ 2.0))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 3.7e-132) tmp = (l * l) * (2.0 / (t * (k ^ 4.0))); elseif (t <= 1.45e+140) tmp = (2.0 / ((k / t) * (k / t))) / ((sin(k) * tan(k)) * (((t ^ 2.0) / l) * (t / l))); else tmp = (l * l) * (2.0 / (((k ^ 2.0) * sqrt(t)) ^ 2.0)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 3.7e-132], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(t * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.45e+140], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] * N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k, 2.0], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.7 \cdot 10^{-132}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{t \cdot {k}^{4}}\\
\mathbf{elif}\;t \leq 1.45 \cdot 10^{+140}:\\
\;\;\;\;\frac{\frac{2}{\frac{k}{t} \cdot \frac{k}{t}}}{\left(\sin k \cdot \tan k\right) \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left({k}^{2} \cdot \sqrt{t}\right)}^{2}}\\
\end{array}
\end{array}
if t < 3.7000000000000002e-132Initial program 32.6%
Simplified41.1%
Taylor expanded in k around 0 60.7%
if 3.7000000000000002e-132 < t < 1.4499999999999999e140Initial program 55.3%
*-commutative55.3%
associate-/r*55.3%
Simplified66.1%
+-rgt-identity66.1%
unpow266.1%
Applied egg-rr66.1%
unpow366.1%
times-frac85.9%
pow285.9%
Applied egg-rr85.8%
if 1.4499999999999999e140 < t Initial program 5.9%
Simplified35.4%
add-sqr-sqrt20.6%
pow220.6%
*-commutative20.6%
sqrt-prod20.6%
associate-*r*20.6%
sqrt-prod23.5%
sqrt-pow126.5%
metadata-eval26.5%
pow126.5%
sqrt-pow138.3%
metadata-eval38.3%
Applied egg-rr38.3%
Taylor expanded in k around 0 76.8%
Final simplification69.6%
(FPCore (t l k)
:precision binary64
(if (<= t 8.4e-113)
(*
(* l l)
(/ 2.0 (* (pow k 4.0) (+ t (* (* t (pow k 2.0)) 0.16666666666666666)))))
(if (<= t 5e+102)
(/
(/ 2.0 (/ (/ k t) (/ t k)))
(/ (* (* (sin k) (tan k)) (/ (pow t 3.0) l)) l))
(* (* l l) (/ 2.0 (pow (* (pow k 2.0) (sqrt t)) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 8.4e-113) {
tmp = (l * l) * (2.0 / (pow(k, 4.0) * (t + ((t * pow(k, 2.0)) * 0.16666666666666666))));
} else if (t <= 5e+102) {
tmp = (2.0 / ((k / t) / (t / k))) / (((sin(k) * tan(k)) * (pow(t, 3.0) / l)) / l);
} else {
tmp = (l * l) * (2.0 / pow((pow(k, 2.0) * sqrt(t)), 2.0));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 8.4d-113) then
tmp = (l * l) * (2.0d0 / ((k ** 4.0d0) * (t + ((t * (k ** 2.0d0)) * 0.16666666666666666d0))))
else if (t <= 5d+102) then
tmp = (2.0d0 / ((k / t) / (t / k))) / (((sin(k) * tan(k)) * ((t ** 3.0d0) / l)) / l)
else
tmp = (l * l) * (2.0d0 / (((k ** 2.0d0) * sqrt(t)) ** 2.0d0))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 8.4e-113) {
tmp = (l * l) * (2.0 / (Math.pow(k, 4.0) * (t + ((t * Math.pow(k, 2.0)) * 0.16666666666666666))));
} else if (t <= 5e+102) {
tmp = (2.0 / ((k / t) / (t / k))) / (((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / l)) / l);
} else {
tmp = (l * l) * (2.0 / Math.pow((Math.pow(k, 2.0) * Math.sqrt(t)), 2.0));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 8.4e-113: tmp = (l * l) * (2.0 / (math.pow(k, 4.0) * (t + ((t * math.pow(k, 2.0)) * 0.16666666666666666)))) elif t <= 5e+102: tmp = (2.0 / ((k / t) / (t / k))) / (((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / l)) / l) else: tmp = (l * l) * (2.0 / math.pow((math.pow(k, 2.0) * math.sqrt(t)), 2.0)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 8.4e-113) tmp = Float64(Float64(l * l) * Float64(2.0 / Float64((k ^ 4.0) * Float64(t + Float64(Float64(t * (k ^ 2.0)) * 0.16666666666666666))))); elseif (t <= 5e+102) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) / Float64(t / k))) / Float64(Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / l)) / l)); else tmp = Float64(Float64(l * l) * Float64(2.0 / (Float64((k ^ 2.0) * sqrt(t)) ^ 2.0))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 8.4e-113) tmp = (l * l) * (2.0 / ((k ^ 4.0) * (t + ((t * (k ^ 2.0)) * 0.16666666666666666)))); elseif (t <= 5e+102) tmp = (2.0 / ((k / t) / (t / k))) / (((sin(k) * tan(k)) * ((t ^ 3.0) / l)) / l); else tmp = (l * l) * (2.0 / (((k ^ 2.0) * sqrt(t)) ^ 2.0)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 8.4e-113], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[k, 4.0], $MachinePrecision] * N[(t + N[(N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5e+102], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k, 2.0], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 8.4 \cdot 10^{-113}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{k}^{4} \cdot \left(t + \left(t \cdot {k}^{2}\right) \cdot 0.16666666666666666\right)}\\
\mathbf{elif}\;t \leq 5 \cdot 10^{+102}:\\
\;\;\;\;\frac{\frac{2}{\frac{\frac{k}{t}}{\frac{t}{k}}}}{\frac{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left({k}^{2} \cdot \sqrt{t}\right)}^{2}}\\
\end{array}
\end{array}
if t < 8.39999999999999999e-113Initial program 32.6%
Simplified41.0%
Taylor expanded in k around 0 60.8%
if 8.39999999999999999e-113 < t < 5e102Initial program 61.5%
*-commutative61.5%
associate-/r*61.6%
Simplified72.9%
+-rgt-identity72.9%
unpow272.9%
clear-num72.9%
un-div-inv72.9%
Applied egg-rr72.9%
associate-/r*83.4%
associate-*l/84.2%
Applied egg-rr84.2%
if 5e102 < t Initial program 9.3%
Simplified34.9%
add-sqr-sqrt18.6%
pow218.6%
*-commutative18.6%
sqrt-prod18.6%
associate-*r*18.6%
sqrt-prod20.9%
sqrt-pow123.3%
metadata-eval23.3%
pow123.3%
sqrt-pow139.6%
metadata-eval39.6%
Applied egg-rr39.6%
Taylor expanded in k around 0 74.7%
Final simplification68.3%
(FPCore (t l k)
:precision binary64
(if (<= t 5.8e-85)
(*
(* l l)
(/ 2.0 (* (pow k 4.0) (+ t (* (* t (pow k 2.0)) 0.16666666666666666)))))
(if (<= t 2.1e+102)
(/
(/ 2.0 (* (/ k t) (/ k t)))
(* (* (sin k) (tan k)) (/ (pow t 3.0) (* l l))))
(* (* l l) (/ 2.0 (pow (* (pow k 2.0) (sqrt t)) 2.0))))))
double code(double t, double l, double k) {
double tmp;
if (t <= 5.8e-85) {
tmp = (l * l) * (2.0 / (pow(k, 4.0) * (t + ((t * pow(k, 2.0)) * 0.16666666666666666))));
} else if (t <= 2.1e+102) {
tmp = (2.0 / ((k / t) * (k / t))) / ((sin(k) * tan(k)) * (pow(t, 3.0) / (l * l)));
} else {
tmp = (l * l) * (2.0 / pow((pow(k, 2.0) * sqrt(t)), 2.0));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 5.8d-85) then
tmp = (l * l) * (2.0d0 / ((k ** 4.0d0) * (t + ((t * (k ** 2.0d0)) * 0.16666666666666666d0))))
else if (t <= 2.1d+102) then
tmp = (2.0d0 / ((k / t) * (k / t))) / ((sin(k) * tan(k)) * ((t ** 3.0d0) / (l * l)))
else
tmp = (l * l) * (2.0d0 / (((k ** 2.0d0) * sqrt(t)) ** 2.0d0))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 5.8e-85) {
tmp = (l * l) * (2.0 / (Math.pow(k, 4.0) * (t + ((t * Math.pow(k, 2.0)) * 0.16666666666666666))));
} else if (t <= 2.1e+102) {
tmp = (2.0 / ((k / t) * (k / t))) / ((Math.sin(k) * Math.tan(k)) * (Math.pow(t, 3.0) / (l * l)));
} else {
tmp = (l * l) * (2.0 / Math.pow((Math.pow(k, 2.0) * Math.sqrt(t)), 2.0));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 5.8e-85: tmp = (l * l) * (2.0 / (math.pow(k, 4.0) * (t + ((t * math.pow(k, 2.0)) * 0.16666666666666666)))) elif t <= 2.1e+102: tmp = (2.0 / ((k / t) * (k / t))) / ((math.sin(k) * math.tan(k)) * (math.pow(t, 3.0) / (l * l))) else: tmp = (l * l) * (2.0 / math.pow((math.pow(k, 2.0) * math.sqrt(t)), 2.0)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 5.8e-85) tmp = Float64(Float64(l * l) * Float64(2.0 / Float64((k ^ 4.0) * Float64(t + Float64(Float64(t * (k ^ 2.0)) * 0.16666666666666666))))); elseif (t <= 2.1e+102) tmp = Float64(Float64(2.0 / Float64(Float64(k / t) * Float64(k / t))) / Float64(Float64(sin(k) * tan(k)) * Float64((t ^ 3.0) / Float64(l * l)))); else tmp = Float64(Float64(l * l) * Float64(2.0 / (Float64((k ^ 2.0) * sqrt(t)) ^ 2.0))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 5.8e-85) tmp = (l * l) * (2.0 / ((k ^ 4.0) * (t + ((t * (k ^ 2.0)) * 0.16666666666666666)))); elseif (t <= 2.1e+102) tmp = (2.0 / ((k / t) * (k / t))) / ((sin(k) * tan(k)) * ((t ^ 3.0) / (l * l))); else tmp = (l * l) * (2.0 / (((k ^ 2.0) * sqrt(t)) ^ 2.0)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 5.8e-85], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[k, 4.0], $MachinePrecision] * N[(t + N[(N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.1e+102], N[(N[(2.0 / N[(N[(k / t), $MachinePrecision] * N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k, 2.0], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 5.8 \cdot 10^{-85}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{k}^{4} \cdot \left(t + \left(t \cdot {k}^{2}\right) \cdot 0.16666666666666666\right)}\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{+102}:\\
\;\;\;\;\frac{\frac{2}{\frac{k}{t} \cdot \frac{k}{t}}}{\left(\sin k \cdot \tan k\right) \cdot \frac{{t}^{3}}{\ell \cdot \ell}}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left({k}^{2} \cdot \sqrt{t}\right)}^{2}}\\
\end{array}
\end{array}
if t < 5.8000000000000004e-85Initial program 34.3%
Simplified42.3%
Taylor expanded in k around 0 61.2%
if 5.8000000000000004e-85 < t < 2.10000000000000001e102Initial program 60.1%
*-commutative60.1%
associate-/r*60.2%
Simplified73.0%
+-rgt-identity73.0%
unpow273.0%
Applied egg-rr73.0%
if 2.10000000000000001e102 < t Initial program 9.3%
Simplified34.9%
add-sqr-sqrt18.6%
pow218.6%
*-commutative18.6%
sqrt-prod18.6%
associate-*r*18.6%
sqrt-prod20.9%
sqrt-pow123.3%
metadata-eval23.3%
pow123.3%
sqrt-pow139.6%
metadata-eval39.6%
Applied egg-rr39.6%
Taylor expanded in k around 0 74.7%
Final simplification65.8%
(FPCore (t l k) :precision binary64 (* (* l l) (/ 2.0 (pow (* (pow k 2.0) (sqrt t)) 2.0))))
double code(double t, double l, double k) {
return (l * l) * (2.0 / pow((pow(k, 2.0) * sqrt(t)), 2.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l * l) * (2.0d0 / (((k ** 2.0d0) * sqrt(t)) ** 2.0d0))
end function
public static double code(double t, double l, double k) {
return (l * l) * (2.0 / Math.pow((Math.pow(k, 2.0) * Math.sqrt(t)), 2.0));
}
def code(t, l, k): return (l * l) * (2.0 / math.pow((math.pow(k, 2.0) * math.sqrt(t)), 2.0))
function code(t, l, k) return Float64(Float64(l * l) * Float64(2.0 / (Float64((k ^ 2.0) * sqrt(t)) ^ 2.0))) end
function tmp = code(t, l, k) tmp = (l * l) * (2.0 / (((k ^ 2.0) * sqrt(t)) ^ 2.0)); end
code[t_, l_, k_] := N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k, 2.0], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\ell \cdot \ell\right) \cdot \frac{2}{{\left({k}^{2} \cdot \sqrt{t}\right)}^{2}}
\end{array}
Initial program 35.1%
Simplified46.3%
add-sqr-sqrt24.8%
pow224.8%
*-commutative24.8%
sqrt-prod19.7%
associate-*r*19.7%
sqrt-prod20.5%
sqrt-pow122.5%
metadata-eval22.5%
pow122.5%
sqrt-pow126.3%
metadata-eval26.3%
Applied egg-rr26.3%
Taylor expanded in k around 0 34.3%
Final simplification34.3%
(FPCore (t l k) :precision binary64 (* (* l l) (/ 2.0 (* (pow k 4.0) (+ t (* (* t (pow k 2.0)) 0.16666666666666666))))))
double code(double t, double l, double k) {
return (l * l) * (2.0 / (pow(k, 4.0) * (t + ((t * pow(k, 2.0)) * 0.16666666666666666))));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l * l) * (2.0d0 / ((k ** 4.0d0) * (t + ((t * (k ** 2.0d0)) * 0.16666666666666666d0))))
end function
public static double code(double t, double l, double k) {
return (l * l) * (2.0 / (Math.pow(k, 4.0) * (t + ((t * Math.pow(k, 2.0)) * 0.16666666666666666))));
}
def code(t, l, k): return (l * l) * (2.0 / (math.pow(k, 4.0) * (t + ((t * math.pow(k, 2.0)) * 0.16666666666666666))))
function code(t, l, k) return Float64(Float64(l * l) * Float64(2.0 / Float64((k ^ 4.0) * Float64(t + Float64(Float64(t * (k ^ 2.0)) * 0.16666666666666666))))) end
function tmp = code(t, l, k) tmp = (l * l) * (2.0 / ((k ^ 4.0) * (t + ((t * (k ^ 2.0)) * 0.16666666666666666)))); end
code[t_, l_, k_] := N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[k, 4.0], $MachinePrecision] * N[(t + N[(N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\ell \cdot \ell\right) \cdot \frac{2}{{k}^{4} \cdot \left(t + \left(t \cdot {k}^{2}\right) \cdot 0.16666666666666666\right)}
\end{array}
Initial program 35.1%
Simplified46.3%
Taylor expanded in k around 0 62.9%
Final simplification62.9%
(FPCore (t l k) :precision binary64 (* (* l l) (/ (/ 2.0 t) (pow k 4.0))))
double code(double t, double l, double k) {
return (l * l) * ((2.0 / t) / pow(k, 4.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l * l) * ((2.0d0 / t) / (k ** 4.0d0))
end function
public static double code(double t, double l, double k) {
return (l * l) * ((2.0 / t) / Math.pow(k, 4.0));
}
def code(t, l, k): return (l * l) * ((2.0 / t) / math.pow(k, 4.0))
function code(t, l, k) return Float64(Float64(l * l) * Float64(Float64(2.0 / t) / (k ^ 4.0))) end
function tmp = code(t, l, k) tmp = (l * l) * ((2.0 / t) / (k ^ 4.0)); end
code[t_, l_, k_] := N[(N[(l * l), $MachinePrecision] * N[(N[(2.0 / t), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\ell \cdot \ell\right) \cdot \frac{\frac{2}{t}}{{k}^{4}}
\end{array}
Initial program 35.1%
Simplified46.3%
Taylor expanded in k around 0 62.7%
*-commutative62.7%
associate-/r*62.7%
Simplified62.7%
Final simplification62.7%
(FPCore (t l k) :precision binary64 (* (* l l) (/ 2.0 (* t (pow k 4.0)))))
double code(double t, double l, double k) {
return (l * l) * (2.0 / (t * pow(k, 4.0)));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l * l) * (2.0d0 / (t * (k ** 4.0d0)))
end function
public static double code(double t, double l, double k) {
return (l * l) * (2.0 / (t * Math.pow(k, 4.0)));
}
def code(t, l, k): return (l * l) * (2.0 / (t * math.pow(k, 4.0)))
function code(t, l, k) return Float64(Float64(l * l) * Float64(2.0 / Float64(t * (k ^ 4.0)))) end
function tmp = code(t, l, k) tmp = (l * l) * (2.0 / (t * (k ^ 4.0))); end
code[t_, l_, k_] := N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(t * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\ell \cdot \ell\right) \cdot \frac{2}{t \cdot {k}^{4}}
\end{array}
Initial program 35.1%
Simplified46.3%
Taylor expanded in k around 0 62.7%
Final simplification62.7%
herbie shell --seed 2024177
(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))))