
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)) (t_2 (pow (cbrt l) 2.0)))
(if (<= t -8.8e+97)
(/ 2.0 (* (* (sin k) (pow (/ t t_2) 3.0)) (* (tan k) (+ 2.0 t_1))))
(if (<= t 5e-24)
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k))))
(/
2.0
(*
(pow (/ (* t (cbrt (sin k))) t_2) 3.0)
(* (tan k) (+ 1.0 (+ t_1 1.0)))))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double t_2 = pow(cbrt(l), 2.0);
double tmp;
if (t <= -8.8e+97) {
tmp = 2.0 / ((sin(k) * pow((t / t_2), 3.0)) * (tan(k) * (2.0 + t_1)));
} else if (t <= 5e-24) {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
} else {
tmp = 2.0 / (pow(((t * cbrt(sin(k))) / t_2), 3.0) * (tan(k) * (1.0 + (t_1 + 1.0))));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double t_2 = Math.pow(Math.cbrt(l), 2.0);
double tmp;
if (t <= -8.8e+97) {
tmp = 2.0 / ((Math.sin(k) * Math.pow((t / t_2), 3.0)) * (Math.tan(k) * (2.0 + t_1)));
} else if (t <= 5e-24) {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
} else {
tmp = 2.0 / (Math.pow(((t * Math.cbrt(Math.sin(k))) / t_2), 3.0) * (Math.tan(k) * (1.0 + (t_1 + 1.0))));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 t_2 = cbrt(l) ^ 2.0 tmp = 0.0 if (t <= -8.8e+97) tmp = Float64(2.0 / Float64(Float64(sin(k) * (Float64(t / t_2) ^ 3.0)) * Float64(tan(k) * Float64(2.0 + t_1)))); elseif (t <= 5e-24) tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); else tmp = Float64(2.0 / Float64((Float64(Float64(t * cbrt(sin(k))) / t_2) ^ 3.0) * Float64(tan(k) * Float64(1.0 + Float64(t_1 + 1.0))))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$2 = N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[t, -8.8e+97], N[(2.0 / N[(N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t / t$95$2), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5e-24], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[(t * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
t_2 := {\left(\sqrt[3]{\ell}\right)}^{2}\\
\mathbf{if}\;t \leq -8.8 \cdot 10^{+97}:\\
\;\;\;\;\frac{2}{\left(\sin k \cdot {\left(\frac{t}{t_2}\right)}^{3}\right) \cdot \left(\tan k \cdot \left(2 + t_1\right)\right)}\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-24}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{t \cdot \sqrt[3]{\sin k}}{t_2}\right)}^{3} \cdot \left(\tan k \cdot \left(1 + \left(t_1 + 1\right)\right)\right)}\\
\end{array}
\end{array}
if t < -8.8000000000000003e97Initial program 58.5%
associate-*l*58.5%
+-commutative58.5%
Simplified58.5%
add-cube-cbrt58.5%
pow358.5%
cbrt-prod58.5%
cbrt-div58.5%
rem-cbrt-cube66.0%
cbrt-prod89.1%
pow289.1%
Applied egg-rr89.1%
pow189.1%
associate-+r+89.1%
metadata-eval89.1%
Applied egg-rr89.1%
unpow189.1%
*-commutative89.1%
cube-prod89.1%
rem-cube-cbrt89.2%
Simplified89.2%
if -8.8000000000000003e97 < t < 4.9999999999999998e-24Initial program 44.2%
associate-/l/44.1%
associate-*l/44.1%
associate-*l/44.1%
associate-/r/44.2%
*-commutative44.2%
associate-/l/44.2%
associate-*r*44.5%
*-commutative44.5%
associate-*r*44.5%
*-commutative44.5%
Simplified44.5%
Taylor expanded in k around inf 78.2%
unpow278.2%
*-commutative78.2%
Simplified78.2%
associate-*r/78.2%
Applied egg-rr78.2%
unpow278.2%
associate-*r/78.2%
unpow278.2%
associate-*l*82.3%
associate-*l*88.8%
*-commutative88.8%
Simplified88.8%
associate-*r/88.8%
Applied egg-rr88.8%
associate-*r*88.8%
associate-/r*92.5%
*-commutative92.5%
Simplified92.5%
associate-*r/89.8%
times-frac89.8%
Applied egg-rr89.8%
associate-*r*89.8%
times-frac96.5%
associate-*r/96.5%
*-commutative96.5%
associate-/r*96.5%
*-rgt-identity96.5%
*-commutative96.5%
associate-*r/96.6%
associate-*l*96.6%
associate-*r/96.5%
*-rgt-identity96.5%
Simplified96.5%
if 4.9999999999999998e-24 < t Initial program 66.9%
associate-*l*66.9%
+-commutative66.9%
Simplified66.9%
add-cube-cbrt66.8%
pow366.8%
cbrt-prod66.7%
cbrt-div66.7%
rem-cbrt-cube74.9%
cbrt-prod93.2%
pow293.2%
Applied egg-rr93.2%
associate-*l/93.3%
Applied egg-rr93.3%
Final simplification94.4%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(+ 1.0 (+ t_1 1.0))
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))))
INFINITY)
(* (/ (* 2.0 l) (+ 2.0 t_1)) (* (/ l (sin k)) (/ (pow t -3.0) (tan k))))
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))))) <= ((double) INFINITY)) {
tmp = ((2.0 * l) / (2.0 + t_1)) * ((l / sin(k)) * (pow(t, -3.0) / tan(k)));
} else {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))))) <= Double.POSITIVE_INFINITY) {
tmp = ((2.0 * l) / (2.0 + t_1)) * ((l / Math.sin(k)) * (Math.pow(t, -3.0) / Math.tan(k)));
} else {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow((k / t), 2.0) tmp = 0 if (2.0 / ((1.0 + (t_1 + 1.0)) * (math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))))) <= math.inf: tmp = ((2.0 * l) / (2.0 + t_1)) * ((l / math.sin(k)) * (math.pow(t, -3.0) / math.tan(k))) else: tmp = (2.0 * (l / (k * math.tan(k)))) * ((l / k) / (t * math.sin(k))) return tmp
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(1.0 + Float64(t_1 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))))) <= Inf) tmp = Float64(Float64(Float64(2.0 * l) / Float64(2.0 + t_1)) * Float64(Float64(l / sin(k)) * Float64((t ^ -3.0) / tan(k)))); else tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (k / t) ^ 2.0; tmp = 0.0; if ((2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))))) <= Inf) tmp = ((2.0 * l) / (2.0 + t_1)) * ((l / sin(k)) * ((t ^ -3.0) / tan(k))); else tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(N[(2.0 * l), $MachinePrecision] / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, -3.0], $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(1 + \left(t_1 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq \infty:\\
\;\;\;\;\frac{2 \cdot \ell}{2 + t_1} \cdot \left(\frac{\ell}{\sin k} \cdot \frac{{t}^{-3}}{\tan k}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\end{array}
\end{array}
if (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) < +inf.0Initial program 86.7%
associate-*l*87.0%
associate-/l/87.0%
*-commutative87.0%
associate-*r/87.0%
associate-/l*87.0%
associate-/r/81.7%
Simplified84.7%
expm1-log1p-u68.4%
expm1-udef61.7%
associate-*l/61.7%
*-commutative61.7%
div-inv61.7%
pow-flip61.7%
metadata-eval61.7%
Applied egg-rr61.7%
expm1-def68.4%
expm1-log1p84.7%
associate-*r*84.7%
times-frac85.4%
Simplified85.4%
*-un-lft-identity85.4%
associate-/l*84.8%
Applied egg-rr84.8%
*-lft-identity84.8%
associate-/r/85.5%
associate-*l/85.4%
times-frac92.4%
Simplified92.4%
if +inf.0 < (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) Initial program 0.0%
associate-/l/0.0%
associate-*l/0.0%
associate-*l/0.0%
associate-/r/0.1%
*-commutative0.1%
associate-/l/0.1%
associate-*r*0.1%
*-commutative0.1%
associate-*r*0.1%
*-commutative0.1%
Simplified0.1%
Taylor expanded in k around inf 54.1%
unpow254.1%
*-commutative54.1%
Simplified54.1%
associate-*r/54.1%
Applied egg-rr54.1%
unpow254.1%
associate-*r/54.1%
unpow254.1%
associate-*l*63.1%
associate-*l*72.5%
*-commutative72.5%
Simplified72.5%
associate-*r/72.5%
Applied egg-rr72.5%
associate-*r*72.6%
associate-/r*77.2%
*-commutative77.2%
Simplified77.2%
associate-*r/72.9%
times-frac72.9%
Applied egg-rr72.9%
associate-*r*72.9%
times-frac83.1%
associate-*r/83.1%
*-commutative83.1%
associate-/r*83.0%
*-rgt-identity83.0%
*-commutative83.0%
associate-*r/83.1%
associate-*l*83.1%
associate-*r/83.0%
*-rgt-identity83.0%
Simplified83.0%
Final simplification88.7%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)) (t_2 (/ t (pow (cbrt l) 2.0))))
(if (<= t -2.15e+98)
(/ 2.0 (* (* (sin k) (pow t_2 3.0)) (* (tan k) (+ 2.0 t_1))))
(if (<= t 6.8e-25)
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k))))
(/
2.0
(*
(* (tan k) (+ 1.0 (+ t_1 1.0)))
(pow (* t_2 (cbrt (sin k))) 3.0)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double t_2 = t / pow(cbrt(l), 2.0);
double tmp;
if (t <= -2.15e+98) {
tmp = 2.0 / ((sin(k) * pow(t_2, 3.0)) * (tan(k) * (2.0 + t_1)));
} else if (t <= 6.8e-25) {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
} else {
tmp = 2.0 / ((tan(k) * (1.0 + (t_1 + 1.0))) * pow((t_2 * cbrt(sin(k))), 3.0));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double t_2 = t / Math.pow(Math.cbrt(l), 2.0);
double tmp;
if (t <= -2.15e+98) {
tmp = 2.0 / ((Math.sin(k) * Math.pow(t_2, 3.0)) * (Math.tan(k) * (2.0 + t_1)));
} else if (t <= 6.8e-25) {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
} else {
tmp = 2.0 / ((Math.tan(k) * (1.0 + (t_1 + 1.0))) * Math.pow((t_2 * Math.cbrt(Math.sin(k))), 3.0));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 t_2 = Float64(t / (cbrt(l) ^ 2.0)) tmp = 0.0 if (t <= -2.15e+98) tmp = Float64(2.0 / Float64(Float64(sin(k) * (t_2 ^ 3.0)) * Float64(tan(k) * Float64(2.0 + t_1)))); elseif (t <= 6.8e-25) tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(1.0 + Float64(t_1 + 1.0))) * (Float64(t_2 * cbrt(sin(k))) ^ 3.0))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$2 = N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.15e+98], N[(2.0 / N[(N[(N[Sin[k], $MachinePrecision] * N[Power[t$95$2, 3.0], $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.8e-25], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[(t$95$2 * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
t_2 := \frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\\
\mathbf{if}\;t \leq -2.15 \cdot 10^{+98}:\\
\;\;\;\;\frac{2}{\left(\sin k \cdot {t_2}^{3}\right) \cdot \left(\tan k \cdot \left(2 + t_1\right)\right)}\\
\mathbf{elif}\;t \leq 6.8 \cdot 10^{-25}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(1 + \left(t_1 + 1\right)\right)\right) \cdot {\left(t_2 \cdot \sqrt[3]{\sin k}\right)}^{3}}\\
\end{array}
\end{array}
if t < -2.1500000000000001e98Initial program 58.5%
associate-*l*58.5%
+-commutative58.5%
Simplified58.5%
add-cube-cbrt58.5%
pow358.5%
cbrt-prod58.5%
cbrt-div58.5%
rem-cbrt-cube66.0%
cbrt-prod89.1%
pow289.1%
Applied egg-rr89.1%
pow189.1%
associate-+r+89.1%
metadata-eval89.1%
Applied egg-rr89.1%
unpow189.1%
*-commutative89.1%
cube-prod89.1%
rem-cube-cbrt89.2%
Simplified89.2%
if -2.1500000000000001e98 < t < 6.80000000000000003e-25Initial program 44.2%
associate-/l/44.1%
associate-*l/44.1%
associate-*l/44.1%
associate-/r/44.2%
*-commutative44.2%
associate-/l/44.2%
associate-*r*44.5%
*-commutative44.5%
associate-*r*44.5%
*-commutative44.5%
Simplified44.5%
Taylor expanded in k around inf 78.2%
unpow278.2%
*-commutative78.2%
Simplified78.2%
associate-*r/78.2%
Applied egg-rr78.2%
unpow278.2%
associate-*r/78.2%
unpow278.2%
associate-*l*82.3%
associate-*l*88.8%
*-commutative88.8%
Simplified88.8%
associate-*r/88.8%
Applied egg-rr88.8%
associate-*r*88.8%
associate-/r*92.5%
*-commutative92.5%
Simplified92.5%
associate-*r/89.8%
times-frac89.8%
Applied egg-rr89.8%
associate-*r*89.8%
times-frac96.5%
associate-*r/96.5%
*-commutative96.5%
associate-/r*96.5%
*-rgt-identity96.5%
*-commutative96.5%
associate-*r/96.6%
associate-*l*96.6%
associate-*r/96.5%
*-rgt-identity96.5%
Simplified96.5%
if 6.80000000000000003e-25 < t Initial program 66.9%
associate-*l*66.9%
+-commutative66.9%
Simplified66.9%
add-cube-cbrt66.8%
pow366.8%
cbrt-prod66.7%
cbrt-div66.7%
rem-cbrt-cube74.9%
cbrt-prod93.2%
pow293.2%
Applied egg-rr93.2%
Final simplification94.4%
(FPCore (t l k)
:precision binary64
(if (or (<= t -8.8e+97) (not (<= t 2.7e-24)))
(/
2.0
(*
(* (sin k) (pow (/ t (pow (cbrt l) 2.0)) 3.0))
(* (tan k) (+ 2.0 (pow (/ k t) 2.0)))))
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k))))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -8.8e+97) || !(t <= 2.7e-24)) {
tmp = 2.0 / ((sin(k) * pow((t / pow(cbrt(l), 2.0)), 3.0)) * (tan(k) * (2.0 + pow((k / t), 2.0))));
} else {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -8.8e+97) || !(t <= 2.7e-24)) {
tmp = 2.0 / ((Math.sin(k) * Math.pow((t / Math.pow(Math.cbrt(l), 2.0)), 3.0)) * (Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))));
} else {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -8.8e+97) || !(t <= 2.7e-24)) tmp = Float64(2.0 / Float64(Float64(sin(k) * (Float64(t / (cbrt(l) ^ 2.0)) ^ 3.0)) * Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))))); else tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -8.8e+97], N[Not[LessEqual[t, 2.7e-24]], $MachinePrecision]], N[(2.0 / N[(N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -8.8 \cdot 10^{+97} \lor \neg \left(t \leq 2.7 \cdot 10^{-24}\right):\\
\;\;\;\;\frac{2}{\left(\sin k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3}\right) \cdot \left(\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\end{array}
\end{array}
if t < -8.8000000000000003e97 or 2.70000000000000007e-24 < t Initial program 63.5%
associate-*l*63.5%
+-commutative63.5%
Simplified63.5%
add-cube-cbrt63.4%
pow363.4%
cbrt-prod63.4%
cbrt-div63.4%
rem-cbrt-cube71.2%
cbrt-prod91.6%
pow291.6%
Applied egg-rr91.6%
pow191.6%
associate-+r+91.6%
metadata-eval91.6%
Applied egg-rr91.6%
unpow191.6%
*-commutative91.6%
cube-prod88.2%
rem-cube-cbrt88.3%
Simplified88.3%
if -8.8000000000000003e97 < t < 2.70000000000000007e-24Initial program 44.2%
associate-/l/44.1%
associate-*l/44.1%
associate-*l/44.1%
associate-/r/44.2%
*-commutative44.2%
associate-/l/44.2%
associate-*r*44.5%
*-commutative44.5%
associate-*r*44.5%
*-commutative44.5%
Simplified44.5%
Taylor expanded in k around inf 78.2%
unpow278.2%
*-commutative78.2%
Simplified78.2%
associate-*r/78.2%
Applied egg-rr78.2%
unpow278.2%
associate-*r/78.2%
unpow278.2%
associate-*l*82.3%
associate-*l*88.8%
*-commutative88.8%
Simplified88.8%
associate-*r/88.8%
Applied egg-rr88.8%
associate-*r*88.8%
associate-/r*92.5%
*-commutative92.5%
Simplified92.5%
associate-*r/89.8%
times-frac89.8%
Applied egg-rr89.8%
associate-*r*89.8%
times-frac96.5%
associate-*r/96.5%
*-commutative96.5%
associate-/r*96.5%
*-rgt-identity96.5%
*-commutative96.5%
associate-*r/96.6%
associate-*l*96.6%
associate-*r/96.5%
*-rgt-identity96.5%
Simplified96.5%
Final simplification93.0%
(FPCore (t l k)
:precision binary64
(let* ((t_1
(/
2.0
(*
(pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k))) 3.0)
(* 2.0 k)))))
(if (<= t -4.2e+100)
t_1
(if (<= t 1.45e-22)
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k))))
(if (<= t 1.16e+106)
(*
(/ (* 2.0 l) (+ 2.0 (pow (/ k t) 2.0)))
(* (/ l (sin k)) (/ (pow t -3.0) (tan k))))
t_1)))))
double code(double t, double l, double k) {
double t_1 = 2.0 / (pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))), 3.0) * (2.0 * k));
double tmp;
if (t <= -4.2e+100) {
tmp = t_1;
} else if (t <= 1.45e-22) {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
} else if (t <= 1.16e+106) {
tmp = ((2.0 * l) / (2.0 + pow((k / t), 2.0))) * ((l / sin(k)) * (pow(t, -3.0) / tan(k)));
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = 2.0 / (Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k))), 3.0) * (2.0 * k));
double tmp;
if (t <= -4.2e+100) {
tmp = t_1;
} else if (t <= 1.45e-22) {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
} else if (t <= 1.16e+106) {
tmp = ((2.0 * l) / (2.0 + Math.pow((k / t), 2.0))) * ((l / Math.sin(k)) * (Math.pow(t, -3.0) / Math.tan(k)));
} else {
tmp = t_1;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(2.0 / Float64((Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) ^ 3.0) * Float64(2.0 * k))) tmp = 0.0 if (t <= -4.2e+100) tmp = t_1; elseif (t <= 1.45e-22) tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); elseif (t <= 1.16e+106) tmp = Float64(Float64(Float64(2.0 * l) / Float64(2.0 + (Float64(k / t) ^ 2.0))) * Float64(Float64(l / sin(k)) * Float64((t ^ -3.0) / tan(k)))); else tmp = t_1; end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(2.0 / N[(N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.2e+100], t$95$1, If[LessEqual[t, 1.45e-22], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.16e+106], N[(N[(N[(2.0 * l), $MachinePrecision] / N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t, -3.0], $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\mathbf{if}\;t \leq -4.2 \cdot 10^{+100}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.45 \cdot 10^{-22}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\mathbf{elif}\;t \leq 1.16 \cdot 10^{+106}:\\
\;\;\;\;\frac{2 \cdot \ell}{2 + {\left(\frac{k}{t}\right)}^{2}} \cdot \left(\frac{\ell}{\sin k} \cdot \frac{{t}^{-3}}{\tan k}\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -4.1999999999999997e100 or 1.16000000000000004e106 < t Initial program 62.8%
associate-*l*62.8%
+-commutative62.8%
Simplified62.8%
add-cube-cbrt62.8%
pow362.8%
cbrt-prod62.8%
cbrt-div62.8%
rem-cbrt-cube73.0%
cbrt-prod93.8%
pow293.8%
Applied egg-rr93.8%
Taylor expanded in k around 0 86.1%
if -4.1999999999999997e100 < t < 1.4500000000000001e-22Initial program 43.9%
associate-/l/43.9%
associate-*l/43.8%
associate-*l/43.8%
associate-/r/43.9%
*-commutative43.9%
associate-/l/43.9%
associate-*r*44.2%
*-commutative44.2%
associate-*r*44.2%
*-commutative44.2%
Simplified44.2%
Taylor expanded in k around inf 77.7%
unpow277.7%
*-commutative77.7%
Simplified77.7%
associate-*r/77.7%
Applied egg-rr77.7%
unpow277.7%
associate-*r/77.7%
unpow277.7%
associate-*l*81.8%
associate-*l*88.2%
*-commutative88.2%
Simplified88.2%
associate-*r/88.2%
Applied egg-rr88.2%
associate-*r*88.3%
associate-/r*92.0%
*-commutative92.0%
Simplified92.0%
associate-*r/89.2%
times-frac89.2%
Applied egg-rr89.2%
associate-*r*89.2%
times-frac95.9%
associate-*r/95.9%
*-commutative95.9%
associate-/r*95.9%
*-rgt-identity95.9%
*-commutative95.9%
associate-*r/96.0%
associate-*l*96.0%
associate-*r/95.9%
*-rgt-identity95.9%
Simplified95.9%
if 1.4500000000000001e-22 < t < 1.16000000000000004e106Initial program 68.6%
associate-*l*68.5%
associate-/l/68.5%
*-commutative68.5%
associate-*r/68.6%
associate-/l*68.4%
associate-/r/68.1%
Simplified75.2%
expm1-log1p-u74.9%
expm1-udef47.4%
associate-*l/47.4%
*-commutative47.4%
div-inv47.4%
pow-flip51.1%
metadata-eval51.1%
Applied egg-rr51.1%
expm1-def78.8%
expm1-log1p79.3%
associate-*r*79.3%
times-frac87.3%
Simplified87.3%
*-un-lft-identity87.3%
associate-/l*83.4%
Applied egg-rr83.4%
*-lft-identity83.4%
associate-/r/87.3%
associate-*l/87.3%
times-frac91.5%
Simplified91.5%
Final simplification92.2%
(FPCore (t l k)
:precision binary64
(let* ((t_1
(*
(* l l)
(/ 2.0 (pow (* (* t (cbrt (sin k))) (cbrt (* 2.0 k))) 3.0)))))
(if (<= t -3e+99)
t_1
(if (<= t 5e-24)
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k))))
(if (<= t 2550000000.0)
(* (/ l k) (/ l (* k (pow t 3.0))))
(if (<= t 1.1e+103)
(* 2.0 (/ (/ (/ (cos k) (* (/ k l) (/ k l))) (pow (sin k) 2.0)) t))
t_1))))))
double code(double t, double l, double k) {
double t_1 = (l * l) * (2.0 / pow(((t * cbrt(sin(k))) * cbrt((2.0 * k))), 3.0));
double tmp;
if (t <= -3e+99) {
tmp = t_1;
} else if (t <= 5e-24) {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
} else if (t <= 2550000000.0) {
tmp = (l / k) * (l / (k * pow(t, 3.0)));
} else if (t <= 1.1e+103) {
tmp = 2.0 * (((cos(k) / ((k / l) * (k / l))) / pow(sin(k), 2.0)) / t);
} else {
tmp = t_1;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = (l * l) * (2.0 / Math.pow(((t * Math.cbrt(Math.sin(k))) * Math.cbrt((2.0 * k))), 3.0));
double tmp;
if (t <= -3e+99) {
tmp = t_1;
} else if (t <= 5e-24) {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
} else if (t <= 2550000000.0) {
tmp = (l / k) * (l / (k * Math.pow(t, 3.0)));
} else if (t <= 1.1e+103) {
tmp = 2.0 * (((Math.cos(k) / ((k / l) * (k / l))) / Math.pow(Math.sin(k), 2.0)) / t);
} else {
tmp = t_1;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(Float64(l * l) * Float64(2.0 / (Float64(Float64(t * cbrt(sin(k))) * cbrt(Float64(2.0 * k))) ^ 3.0))) tmp = 0.0 if (t <= -3e+99) tmp = t_1; elseif (t <= 5e-24) tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); elseif (t <= 2550000000.0) tmp = Float64(Float64(l / k) * Float64(l / Float64(k * (t ^ 3.0)))); elseif (t <= 1.1e+103) tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) / Float64(Float64(k / l) * Float64(k / l))) / (sin(k) ^ 2.0)) / t)); else tmp = t_1; end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[Power[N[(N[(t * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision] * N[Power[N[(2.0 * k), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3e+99], t$95$1, If[LessEqual[t, 5e-24], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2550000000.0], N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.1e+103], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] / N[(N[(k / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\ell \cdot \ell\right) \cdot \frac{2}{{\left(\left(t \cdot \sqrt[3]{\sin k}\right) \cdot \sqrt[3]{2 \cdot k}\right)}^{3}}\\
\mathbf{if}\;t \leq -3 \cdot 10^{+99}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-24}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\mathbf{elif}\;t \leq 2550000000:\\
\;\;\;\;\frac{\ell}{k} \cdot \frac{\ell}{k \cdot {t}^{3}}\\
\mathbf{elif}\;t \leq 1.1 \cdot 10^{+103}:\\
\;\;\;\;2 \cdot \frac{\frac{\frac{\cos k}{\frac{k}{\ell} \cdot \frac{k}{\ell}}}{{\sin k}^{2}}}{t}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -3.00000000000000014e99 or 1.09999999999999996e103 < t Initial program 62.8%
associate-/l/62.8%
associate-*l/62.8%
associate-*l/62.8%
associate-/r/62.8%
*-commutative62.8%
associate-/l/62.8%
associate-*r*62.8%
*-commutative62.8%
associate-*r*62.8%
*-commutative62.8%
Simplified62.8%
add-cube-cbrt62.8%
pow362.8%
Applied egg-rr77.8%
Taylor expanded in k around 0 77.8%
*-commutative77.8%
Simplified77.8%
if -3.00000000000000014e99 < t < 4.9999999999999998e-24Initial program 43.9%
associate-/l/43.9%
associate-*l/43.8%
associate-*l/43.8%
associate-/r/43.9%
*-commutative43.9%
associate-/l/43.9%
associate-*r*44.2%
*-commutative44.2%
associate-*r*44.2%
*-commutative44.2%
Simplified44.2%
Taylor expanded in k around inf 77.7%
unpow277.7%
*-commutative77.7%
Simplified77.7%
associate-*r/77.7%
Applied egg-rr77.7%
unpow277.7%
associate-*r/77.7%
unpow277.7%
associate-*l*81.8%
associate-*l*88.2%
*-commutative88.2%
Simplified88.2%
associate-*r/88.2%
Applied egg-rr88.2%
associate-*r*88.3%
associate-/r*92.0%
*-commutative92.0%
Simplified92.0%
associate-*r/89.2%
times-frac89.2%
Applied egg-rr89.2%
associate-*r*89.2%
times-frac95.9%
associate-*r/95.9%
*-commutative95.9%
associate-/r*95.9%
*-rgt-identity95.9%
*-commutative95.9%
associate-*r/96.0%
associate-*l*96.0%
associate-*r/95.9%
*-rgt-identity95.9%
Simplified95.9%
if 4.9999999999999998e-24 < t < 2.55e9Initial program 54.6%
associate-/l/54.6%
associate-*l/54.8%
associate-*l/54.0%
associate-/r/54.4%
*-commutative54.4%
associate-/l/54.4%
associate-*r*54.4%
*-commutative54.4%
associate-*r*54.4%
*-commutative54.4%
Simplified54.4%
Taylor expanded in k around 0 54.2%
unpow254.2%
*-commutative54.2%
times-frac75.0%
unpow275.0%
Simplified75.0%
Taylor expanded in l around 0 54.2%
unpow254.2%
*-commutative54.2%
unpow254.2%
associate-*r*54.2%
times-frac88.0%
Simplified88.0%
if 2.55e9 < t < 1.09999999999999996e103Initial program 75.5%
associate-/l/75.3%
associate-*l/75.2%
associate-*l/75.1%
associate-/r/74.9%
*-commutative74.9%
associate-/l/75.0%
associate-*r*75.1%
*-commutative75.1%
associate-*r*75.0%
*-commutative75.0%
Simplified75.0%
Taylor expanded in k around inf 68.3%
unpow268.3%
*-commutative68.3%
Simplified68.3%
associate-*r/68.3%
Applied egg-rr68.3%
unpow268.3%
associate-*r/68.3%
unpow268.3%
associate-*l*74.6%
associate-*l*74.6%
*-commutative74.6%
Simplified74.6%
Taylor expanded in l around 0 68.4%
associate-/r*68.5%
associate-/r*68.5%
unpow268.5%
times-frac68.7%
unpow268.7%
Simplified68.7%
Taylor expanded in k around inf 68.5%
associate-/l*68.5%
unpow268.5%
unpow268.5%
times-frac86.8%
Simplified86.8%
Final simplification89.1%
(FPCore (t l k)
:precision binary64
(if (<= t -3e+99)
(* (pow (/ (cbrt l) t) 3.0) (/ (/ l k) k))
(if (<= t 6e-22)
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k))))
(if (or (<= t 29500.0) (not (<= t 6e+120)))
(* (/ l k) (/ l (* k (pow t 3.0))))
(* 2.0 (/ (/ (/ (cos k) (* (/ k l) (/ k l))) (pow (sin k) 2.0)) t))))))
double code(double t, double l, double k) {
double tmp;
if (t <= -3e+99) {
tmp = pow((cbrt(l) / t), 3.0) * ((l / k) / k);
} else if (t <= 6e-22) {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
} else if ((t <= 29500.0) || !(t <= 6e+120)) {
tmp = (l / k) * (l / (k * pow(t, 3.0)));
} else {
tmp = 2.0 * (((cos(k) / ((k / l) * (k / l))) / pow(sin(k), 2.0)) / t);
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= -3e+99) {
tmp = Math.pow((Math.cbrt(l) / t), 3.0) * ((l / k) / k);
} else if (t <= 6e-22) {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
} else if ((t <= 29500.0) || !(t <= 6e+120)) {
tmp = (l / k) * (l / (k * Math.pow(t, 3.0)));
} else {
tmp = 2.0 * (((Math.cos(k) / ((k / l) * (k / l))) / Math.pow(Math.sin(k), 2.0)) / t);
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= -3e+99) tmp = Float64((Float64(cbrt(l) / t) ^ 3.0) * Float64(Float64(l / k) / k)); elseif (t <= 6e-22) tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); elseif ((t <= 29500.0) || !(t <= 6e+120)) tmp = Float64(Float64(l / k) * Float64(l / Float64(k * (t ^ 3.0)))); else tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) / Float64(Float64(k / l) * Float64(k / l))) / (sin(k) ^ 2.0)) / t)); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, -3e+99], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6e-22], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, 29500.0], N[Not[LessEqual[t, 6e+120]], $MachinePrecision]], N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] / N[(N[(k / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3 \cdot 10^{+99}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\ell}}{t}\right)}^{3} \cdot \frac{\frac{\ell}{k}}{k}\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-22}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\mathbf{elif}\;t \leq 29500 \lor \neg \left(t \leq 6 \cdot 10^{+120}\right):\\
\;\;\;\;\frac{\ell}{k} \cdot \frac{\ell}{k \cdot {t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\frac{\frac{\cos k}{\frac{k}{\ell} \cdot \frac{k}{\ell}}}{{\sin k}^{2}}}{t}\\
\end{array}
\end{array}
if t < -3.00000000000000014e99Initial program 59.8%
associate-/l/59.8%
associate-*l/59.8%
associate-*l/59.8%
associate-/r/59.8%
*-commutative59.8%
associate-/l/59.8%
associate-*r*59.8%
*-commutative59.8%
associate-*r*59.8%
*-commutative59.8%
Simplified59.8%
Taylor expanded in k around 0 50.1%
unpow250.1%
*-commutative50.1%
times-frac57.3%
unpow257.3%
Simplified57.3%
add-cube-cbrt57.3%
pow257.3%
cbrt-div57.3%
rem-cbrt-cube57.3%
cbrt-div57.3%
rem-cbrt-cube66.3%
Applied egg-rr66.3%
pow-plus66.3%
metadata-eval66.3%
Simplified66.3%
Taylor expanded in l around 0 66.3%
unpow266.3%
associate-/r*71.0%
Simplified71.0%
if -3.00000000000000014e99 < t < 5.9999999999999998e-22Initial program 43.9%
associate-/l/43.9%
associate-*l/43.8%
associate-*l/43.8%
associate-/r/43.9%
*-commutative43.9%
associate-/l/43.9%
associate-*r*44.2%
*-commutative44.2%
associate-*r*44.2%
*-commutative44.2%
Simplified44.2%
Taylor expanded in k around inf 77.7%
unpow277.7%
*-commutative77.7%
Simplified77.7%
associate-*r/77.7%
Applied egg-rr77.7%
unpow277.7%
associate-*r/77.7%
unpow277.7%
associate-*l*81.8%
associate-*l*88.2%
*-commutative88.2%
Simplified88.2%
associate-*r/88.2%
Applied egg-rr88.2%
associate-*r*88.3%
associate-/r*92.0%
*-commutative92.0%
Simplified92.0%
associate-*r/89.2%
times-frac89.2%
Applied egg-rr89.2%
associate-*r*89.2%
times-frac95.9%
associate-*r/95.9%
*-commutative95.9%
associate-/r*95.9%
*-rgt-identity95.9%
*-commutative95.9%
associate-*r/96.0%
associate-*l*96.0%
associate-*r/95.9%
*-rgt-identity95.9%
Simplified95.9%
if 5.9999999999999998e-22 < t < 29500 or 6e120 < t Initial program 64.6%
associate-/l/64.6%
associate-*l/64.6%
associate-*l/64.5%
associate-/r/64.5%
*-commutative64.5%
associate-/l/64.5%
associate-*r*64.5%
*-commutative64.5%
associate-*r*64.5%
*-commutative64.5%
Simplified64.5%
Taylor expanded in k around 0 55.3%
unpow255.3%
*-commutative55.3%
times-frac61.7%
unpow261.7%
Simplified61.7%
Taylor expanded in l around 0 55.3%
unpow255.3%
*-commutative55.3%
unpow255.3%
associate-*r*64.5%
times-frac73.2%
Simplified73.2%
if 29500 < t < 6e120Initial program 71.8%
associate-/l/71.7%
associate-*l/71.6%
associate-*l/71.5%
associate-/r/71.4%
*-commutative71.4%
associate-/l/71.5%
associate-*r*71.5%
*-commutative71.5%
associate-*r*71.5%
*-commutative71.5%
Simplified71.5%
Taylor expanded in k around inf 75.9%
unpow275.9%
*-commutative75.9%
Simplified75.9%
associate-*r/75.8%
Applied egg-rr75.8%
unpow275.8%
associate-*r/75.9%
unpow275.9%
associate-*l*80.7%
associate-*l*80.7%
*-commutative80.7%
Simplified80.7%
Taylor expanded in l around 0 75.9%
associate-/r*76.0%
associate-/r*76.0%
unpow276.0%
times-frac76.2%
unpow276.2%
Simplified76.2%
Taylor expanded in k around inf 76.0%
associate-/l*76.0%
unpow276.0%
unpow276.0%
times-frac89.9%
Simplified89.9%
Final simplification87.2%
(FPCore (t l k)
:precision binary64
(if (<= t -7e+100)
(* (pow (/ (cbrt l) t) 3.0) (/ (/ l k) k))
(if (or (<= t 6.8e-22) (and (not (<= t 800000000.0)) (<= t 5.1e+120)))
(* (* 2.0 (/ l (* k (tan k)))) (/ (/ l k) (* t (sin k))))
(* (/ l k) (/ l (* k (pow t 3.0)))))))
double code(double t, double l, double k) {
double tmp;
if (t <= -7e+100) {
tmp = pow((cbrt(l) / t), 3.0) * ((l / k) / k);
} else if ((t <= 6.8e-22) || (!(t <= 800000000.0) && (t <= 5.1e+120))) {
tmp = (2.0 * (l / (k * tan(k)))) * ((l / k) / (t * sin(k)));
} else {
tmp = (l / k) * (l / (k * pow(t, 3.0)));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (t <= -7e+100) {
tmp = Math.pow((Math.cbrt(l) / t), 3.0) * ((l / k) / k);
} else if ((t <= 6.8e-22) || (!(t <= 800000000.0) && (t <= 5.1e+120))) {
tmp = (2.0 * (l / (k * Math.tan(k)))) * ((l / k) / (t * Math.sin(k)));
} else {
tmp = (l / k) * (l / (k * Math.pow(t, 3.0)));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (t <= -7e+100) tmp = Float64((Float64(cbrt(l) / t) ^ 3.0) * Float64(Float64(l / k) / k)); elseif ((t <= 6.8e-22) || (!(t <= 800000000.0) && (t <= 5.1e+120))) tmp = Float64(Float64(2.0 * Float64(l / Float64(k * tan(k)))) * Float64(Float64(l / k) / Float64(t * sin(k)))); else tmp = Float64(Float64(l / k) * Float64(l / Float64(k * (t ^ 3.0)))); end return tmp end
code[t_, l_, k_] := If[LessEqual[t, -7e+100], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, 6.8e-22], And[N[Not[LessEqual[t, 800000000.0]], $MachinePrecision], LessEqual[t, 5.1e+120]]], N[(N[(2.0 * N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7 \cdot 10^{+100}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\ell}}{t}\right)}^{3} \cdot \frac{\frac{\ell}{k}}{k}\\
\mathbf{elif}\;t \leq 6.8 \cdot 10^{-22} \lor \neg \left(t \leq 800000000\right) \land t \leq 5.1 \cdot 10^{+120}:\\
\;\;\;\;\left(2 \cdot \frac{\ell}{k \cdot \tan k}\right) \cdot \frac{\frac{\ell}{k}}{t \cdot \sin k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\ell}{k} \cdot \frac{\ell}{k \cdot {t}^{3}}\\
\end{array}
\end{array}
if t < -6.99999999999999953e100Initial program 59.8%
associate-/l/59.8%
associate-*l/59.8%
associate-*l/59.8%
associate-/r/59.8%
*-commutative59.8%
associate-/l/59.8%
associate-*r*59.8%
*-commutative59.8%
associate-*r*59.8%
*-commutative59.8%
Simplified59.8%
Taylor expanded in k around 0 50.1%
unpow250.1%
*-commutative50.1%
times-frac57.3%
unpow257.3%
Simplified57.3%
add-cube-cbrt57.3%
pow257.3%
cbrt-div57.3%
rem-cbrt-cube57.3%
cbrt-div57.3%
rem-cbrt-cube66.3%
Applied egg-rr66.3%
pow-plus66.3%
metadata-eval66.3%
Simplified66.3%
Taylor expanded in l around 0 66.3%
unpow266.3%
associate-/r*71.0%
Simplified71.0%
if -6.99999999999999953e100 < t < 6.7999999999999997e-22 or 8e8 < t < 5.10000000000000027e120Initial program 47.4%
associate-/l/47.3%
associate-*l/47.3%
associate-*l/47.3%
associate-/r/47.3%
*-commutative47.3%
associate-/l/47.4%
associate-*r*47.6%
*-commutative47.6%
associate-*r*47.6%
*-commutative47.6%
Simplified47.6%
Taylor expanded in k around inf 77.5%
unpow277.5%
*-commutative77.5%
Simplified77.5%
associate-*r/77.5%
Applied egg-rr77.5%
unpow277.5%
associate-*r/77.5%
unpow277.5%
associate-*l*81.6%
associate-*l*87.3%
*-commutative87.3%
Simplified87.3%
associate-*r/87.3%
Applied egg-rr87.3%
associate-*r*87.3%
associate-/r*91.1%
*-commutative91.1%
Simplified91.1%
associate-*r/88.1%
times-frac88.2%
Applied egg-rr88.2%
associate-*r*88.2%
times-frac95.2%
associate-*r/95.2%
*-commutative95.2%
associate-/r*95.2%
*-rgt-identity95.2%
*-commutative95.2%
associate-*r/95.2%
associate-*l*95.2%
associate-*r/95.2%
*-rgt-identity95.2%
Simplified95.2%
if 6.7999999999999997e-22 < t < 8e8 or 5.10000000000000027e120 < t Initial program 64.6%
associate-/l/64.6%
associate-*l/64.6%
associate-*l/64.5%
associate-/r/64.5%
*-commutative64.5%
associate-/l/64.5%
associate-*r*64.5%
*-commutative64.5%
associate-*r*64.5%
*-commutative64.5%
Simplified64.5%
Taylor expanded in k around 0 55.3%
unpow255.3%
*-commutative55.3%
times-frac61.7%
unpow261.7%
Simplified61.7%
Taylor expanded in l around 0 55.3%
unpow255.3%
*-commutative55.3%
unpow255.3%
associate-*r*64.5%
times-frac73.2%
Simplified73.2%
Final simplification87.2%
(FPCore (t l k) :precision binary64 (if (or (<= k -1.2e-18) (not (<= k 5.2e-16))) (* l (* l (/ 2.0 (* (tan k) (* k (* k (* t (sin k)))))))) (* (pow (/ (cbrt l) t) 3.0) (/ (/ l k) k))))
double code(double t, double l, double k) {
double tmp;
if ((k <= -1.2e-18) || !(k <= 5.2e-16)) {
tmp = l * (l * (2.0 / (tan(k) * (k * (k * (t * sin(k)))))));
} else {
tmp = pow((cbrt(l) / t), 3.0) * ((l / k) / k);
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((k <= -1.2e-18) || !(k <= 5.2e-16)) {
tmp = l * (l * (2.0 / (Math.tan(k) * (k * (k * (t * Math.sin(k)))))));
} else {
tmp = Math.pow((Math.cbrt(l) / t), 3.0) * ((l / k) / k);
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((k <= -1.2e-18) || !(k <= 5.2e-16)) tmp = Float64(l * Float64(l * Float64(2.0 / Float64(tan(k) * Float64(k * Float64(k * Float64(t * sin(k)))))))); else tmp = Float64((Float64(cbrt(l) / t) ^ 3.0) * Float64(Float64(l / k) / k)); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[k, -1.2e-18], N[Not[LessEqual[k, 5.2e-16]], $MachinePrecision]], N[(l * N[(l * N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(k * N[(k * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.2 \cdot 10^{-18} \lor \neg \left(k \leq 5.2 \cdot 10^{-16}\right):\\
\;\;\;\;\ell \cdot \left(\ell \cdot \frac{2}{\tan k \cdot \left(k \cdot \left(k \cdot \left(t \cdot \sin k\right)\right)\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\ell}}{t}\right)}^{3} \cdot \frac{\frac{\ell}{k}}{k}\\
\end{array}
\end{array}
if k < -1.19999999999999997e-18 or 5.1999999999999997e-16 < k Initial program 49.2%
associate-/l/49.2%
associate-*l/49.2%
associate-*l/49.2%
associate-/r/49.3%
*-commutative49.3%
associate-/l/49.3%
associate-*r*49.3%
*-commutative49.3%
associate-*r*49.3%
*-commutative49.3%
Simplified49.3%
Taylor expanded in k around inf 76.3%
unpow276.3%
*-commutative76.3%
Simplified76.3%
associate-*r/76.3%
Applied egg-rr76.3%
unpow276.3%
associate-*r/76.3%
unpow276.3%
associate-*l*80.6%
associate-*l*86.8%
*-commutative86.8%
Simplified86.8%
if -1.19999999999999997e-18 < k < 5.1999999999999997e-16Initial program 57.4%
associate-/l/57.4%
associate-*l/57.4%
associate-*l/57.3%
associate-/r/57.3%
*-commutative57.3%
associate-/l/57.3%
associate-*r*57.8%
*-commutative57.8%
associate-*r*57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in k around 0 53.1%
unpow253.1%
*-commutative53.1%
times-frac59.2%
unpow259.2%
Simplified59.2%
add-cube-cbrt59.2%
pow259.2%
cbrt-div59.2%
rem-cbrt-cube59.1%
cbrt-div59.1%
rem-cbrt-cube66.0%
Applied egg-rr66.0%
pow-plus66.0%
metadata-eval66.0%
Simplified66.0%
Taylor expanded in l around 0 66.0%
unpow266.0%
associate-/r*73.8%
Simplified73.8%
Final simplification81.7%
(FPCore (t l k) :precision binary64 (if (or (<= k -1.95e-18) (not (<= k 4.1e-16))) (* l (* (/ l k) (/ 2.0 (* (* k (tan k)) (* t (sin k)))))) (* (pow (/ (cbrt l) t) 3.0) (/ (/ l k) k))))
double code(double t, double l, double k) {
double tmp;
if ((k <= -1.95e-18) || !(k <= 4.1e-16)) {
tmp = l * ((l / k) * (2.0 / ((k * tan(k)) * (t * sin(k)))));
} else {
tmp = pow((cbrt(l) / t), 3.0) * ((l / k) / k);
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((k <= -1.95e-18) || !(k <= 4.1e-16)) {
tmp = l * ((l / k) * (2.0 / ((k * Math.tan(k)) * (t * Math.sin(k)))));
} else {
tmp = Math.pow((Math.cbrt(l) / t), 3.0) * ((l / k) / k);
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((k <= -1.95e-18) || !(k <= 4.1e-16)) tmp = Float64(l * Float64(Float64(l / k) * Float64(2.0 / Float64(Float64(k * tan(k)) * Float64(t * sin(k)))))); else tmp = Float64((Float64(cbrt(l) / t) ^ 3.0) * Float64(Float64(l / k) / k)); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[k, -1.95e-18], N[Not[LessEqual[k, 4.1e-16]], $MachinePrecision]], N[(l * N[(N[(l / k), $MachinePrecision] * N[(2.0 / N[(N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(t * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.95 \cdot 10^{-18} \lor \neg \left(k \leq 4.1 \cdot 10^{-16}\right):\\
\;\;\;\;\ell \cdot \left(\frac{\ell}{k} \cdot \frac{2}{\left(k \cdot \tan k\right) \cdot \left(t \cdot \sin k\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\ell}}{t}\right)}^{3} \cdot \frac{\frac{\ell}{k}}{k}\\
\end{array}
\end{array}
if k < -1.95000000000000002e-18 or 4.10000000000000006e-16 < k Initial program 49.2%
associate-/l/49.2%
associate-*l/49.2%
associate-*l/49.2%
associate-/r/49.3%
*-commutative49.3%
associate-/l/49.3%
associate-*r*49.3%
*-commutative49.3%
associate-*r*49.3%
*-commutative49.3%
Simplified49.3%
Taylor expanded in k around inf 76.3%
unpow276.3%
*-commutative76.3%
Simplified76.3%
associate-*r/76.3%
Applied egg-rr76.3%
unpow276.3%
associate-*r/76.3%
unpow276.3%
associate-*l*80.6%
associate-*l*86.8%
*-commutative86.8%
Simplified86.8%
associate-*r/86.8%
Applied egg-rr86.8%
associate-*r*86.8%
associate-/r*89.3%
*-commutative89.3%
Simplified89.3%
div-inv89.3%
times-frac89.2%
Applied egg-rr89.2%
*-commutative89.2%
associate-*l/89.3%
associate-*r/89.3%
associate-/r*89.3%
times-frac86.8%
*-lft-identity86.8%
associate-*l*86.9%
*-commutative86.9%
times-frac89.3%
Simplified89.3%
if -1.95000000000000002e-18 < k < 4.10000000000000006e-16Initial program 57.4%
associate-/l/57.4%
associate-*l/57.4%
associate-*l/57.3%
associate-/r/57.3%
*-commutative57.3%
associate-/l/57.3%
associate-*r*57.8%
*-commutative57.8%
associate-*r*57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in k around 0 53.1%
unpow253.1%
*-commutative53.1%
times-frac59.2%
unpow259.2%
Simplified59.2%
add-cube-cbrt59.2%
pow259.2%
cbrt-div59.2%
rem-cbrt-cube59.1%
cbrt-div59.1%
rem-cbrt-cube66.0%
Applied egg-rr66.0%
pow-plus66.0%
metadata-eval66.0%
Simplified66.0%
Taylor expanded in l around 0 66.0%
unpow266.0%
associate-/r*73.8%
Simplified73.8%
Final simplification83.2%
(FPCore (t l k) :precision binary64 (if (or (<= t -0.0062) (not (<= t 1.35e-25))) (* (pow (/ (cbrt l) t) 3.0) (/ (/ l k) k)) (* 2.0 (/ (/ (* (/ l k) (/ l k)) (pow (sin k) 2.0)) t))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -0.0062) || !(t <= 1.35e-25)) {
tmp = pow((cbrt(l) / t), 3.0) * ((l / k) / k);
} else {
tmp = 2.0 * ((((l / k) * (l / k)) / pow(sin(k), 2.0)) / t);
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -0.0062) || !(t <= 1.35e-25)) {
tmp = Math.pow((Math.cbrt(l) / t), 3.0) * ((l / k) / k);
} else {
tmp = 2.0 * ((((l / k) * (l / k)) / Math.pow(Math.sin(k), 2.0)) / t);
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -0.0062) || !(t <= 1.35e-25)) tmp = Float64((Float64(cbrt(l) / t) ^ 3.0) * Float64(Float64(l / k) / k)); else tmp = Float64(2.0 * Float64(Float64(Float64(Float64(l / k) * Float64(l / k)) / (sin(k) ^ 2.0)) / t)); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -0.0062], N[Not[LessEqual[t, 1.35e-25]], $MachinePrecision]], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -0.0062 \lor \neg \left(t \leq 1.35 \cdot 10^{-25}\right):\\
\;\;\;\;{\left(\frac{\sqrt[3]{\ell}}{t}\right)}^{3} \cdot \frac{\frac{\ell}{k}}{k}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\frac{\frac{\ell}{k} \cdot \frac{\ell}{k}}{{\sin k}^{2}}}{t}\\
\end{array}
\end{array}
if t < -0.00619999999999999978 or 1.35000000000000008e-25 < t Initial program 65.8%
associate-/l/65.8%
associate-*l/65.8%
associate-*l/65.7%
associate-/r/65.0%
*-commutative65.0%
associate-/l/65.0%
associate-*r*65.0%
*-commutative65.0%
associate-*r*65.0%
*-commutative65.0%
Simplified65.0%
Taylor expanded in k around 0 55.3%
unpow255.3%
*-commutative55.3%
times-frac60.2%
unpow260.2%
Simplified60.2%
add-cube-cbrt60.2%
pow260.2%
cbrt-div60.2%
rem-cbrt-cube60.1%
cbrt-div60.1%
rem-cbrt-cube65.6%
Applied egg-rr65.6%
pow-plus65.6%
metadata-eval65.6%
Simplified65.6%
Taylor expanded in l around 0 65.6%
unpow265.6%
associate-/r*71.3%
Simplified71.3%
if -0.00619999999999999978 < t < 1.35000000000000008e-25Initial program 39.5%
associate-/l/39.5%
associate-*l/39.5%
associate-*l/39.5%
associate-/r/40.3%
*-commutative40.3%
associate-/l/40.3%
associate-*r*40.7%
*-commutative40.7%
associate-*r*40.7%
*-commutative40.7%
Simplified40.7%
Taylor expanded in k around inf 78.5%
unpow278.5%
*-commutative78.5%
Simplified78.5%
associate-*r/78.6%
Applied egg-rr78.6%
unpow278.6%
associate-*r/78.5%
unpow278.5%
associate-*l*83.0%
associate-*l*90.4%
*-commutative90.4%
Simplified90.4%
Taylor expanded in l around 0 78.5%
associate-/r*76.3%
associate-/r*76.4%
unpow276.4%
times-frac81.8%
unpow281.8%
Simplified81.8%
Taylor expanded in k around 0 65.0%
unpow265.0%
unpow265.0%
times-frac69.9%
Simplified69.9%
Final simplification70.6%
(FPCore (t l k) :precision binary64 (if (or (<= t -7.6e-40) (not (<= t 5e-49))) (* (pow (/ (cbrt l) t) 3.0) (/ (/ l k) k)) (* (/ l t) (/ (* 2.0 l) (pow k 4.0)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -7.6e-40) || !(t <= 5e-49)) {
tmp = pow((cbrt(l) / t), 3.0) * ((l / k) / k);
} else {
tmp = (l / t) * ((2.0 * l) / pow(k, 4.0));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -7.6e-40) || !(t <= 5e-49)) {
tmp = Math.pow((Math.cbrt(l) / t), 3.0) * ((l / k) / k);
} else {
tmp = (l / t) * ((2.0 * l) / Math.pow(k, 4.0));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -7.6e-40) || !(t <= 5e-49)) tmp = Float64((Float64(cbrt(l) / t) ^ 3.0) * Float64(Float64(l / k) / k)); else tmp = Float64(Float64(l / t) * Float64(Float64(2.0 * l) / (k ^ 4.0))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -7.6e-40], N[Not[LessEqual[t, 5e-49]], $MachinePrecision]], N[(N[Power[N[(N[Power[l, 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], N[(N[(l / t), $MachinePrecision] * N[(N[(2.0 * l), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7.6 \cdot 10^{-40} \lor \neg \left(t \leq 5 \cdot 10^{-49}\right):\\
\;\;\;\;{\left(\frac{\sqrt[3]{\ell}}{t}\right)}^{3} \cdot \frac{\frac{\ell}{k}}{k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\ell}{t} \cdot \frac{2 \cdot \ell}{{k}^{4}}\\
\end{array}
\end{array}
if t < -7.5999999999999998e-40 or 4.9999999999999999e-49 < t Initial program 67.9%
associate-/l/67.8%
associate-*l/67.8%
associate-*l/67.8%
associate-/r/67.1%
*-commutative67.1%
associate-/l/67.2%
associate-*r*67.2%
*-commutative67.2%
associate-*r*67.2%
*-commutative67.2%
Simplified67.2%
Taylor expanded in k around 0 58.6%
unpow258.6%
*-commutative58.6%
times-frac63.0%
unpow263.0%
Simplified63.0%
add-cube-cbrt62.9%
pow262.9%
cbrt-div63.0%
rem-cbrt-cube62.9%
cbrt-div62.9%
rem-cbrt-cube67.8%
Applied egg-rr67.8%
pow-plus67.8%
metadata-eval67.8%
Simplified67.8%
Taylor expanded in l around 0 67.8%
unpow267.8%
associate-/r*72.7%
Simplified72.7%
if -7.5999999999999998e-40 < t < 4.9999999999999999e-49Initial program 33.0%
associate-/l/33.0%
associate-*l/32.9%
associate-*l/32.9%
associate-/r/33.8%
*-commutative33.8%
associate-/l/33.8%
associate-*r*34.2%
*-commutative34.2%
associate-*r*34.2%
*-commutative34.2%
Simplified34.2%
Taylor expanded in k around inf 77.8%
unpow277.8%
*-commutative77.8%
Simplified77.8%
associate-*r/77.8%
Applied egg-rr77.8%
unpow277.8%
associate-*r/77.8%
unpow277.8%
associate-*l*83.0%
associate-*l*91.4%
*-commutative91.4%
Simplified91.4%
Taylor expanded in k around 0 59.0%
associate-*r/59.0%
*-commutative59.0%
unpow259.0%
associate-*l*59.0%
*-commutative59.0%
times-frac65.3%
*-commutative65.3%
Simplified65.3%
Final simplification69.5%
(FPCore (t l k) :precision binary64 (if (or (<= t -3.8e-35) (not (<= t 4.8e-48))) (* (* l (pow t -3.0)) (/ l (* k k))) (* (/ l t) (/ (* 2.0 l) (pow k 4.0)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -3.8e-35) || !(t <= 4.8e-48)) {
tmp = (l * pow(t, -3.0)) * (l / (k * k));
} else {
tmp = (l / t) * ((2.0 * l) / pow(k, 4.0));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((t <= (-3.8d-35)) .or. (.not. (t <= 4.8d-48))) then
tmp = (l * (t ** (-3.0d0))) * (l / (k * k))
else
tmp = (l / t) * ((2.0d0 * l) / (k ** 4.0d0))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -3.8e-35) || !(t <= 4.8e-48)) {
tmp = (l * Math.pow(t, -3.0)) * (l / (k * k));
} else {
tmp = (l / t) * ((2.0 * l) / Math.pow(k, 4.0));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -3.8e-35) or not (t <= 4.8e-48): tmp = (l * math.pow(t, -3.0)) * (l / (k * k)) else: tmp = (l / t) * ((2.0 * l) / math.pow(k, 4.0)) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -3.8e-35) || !(t <= 4.8e-48)) tmp = Float64(Float64(l * (t ^ -3.0)) * Float64(l / Float64(k * k))); else tmp = Float64(Float64(l / t) * Float64(Float64(2.0 * l) / (k ^ 4.0))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -3.8e-35) || ~((t <= 4.8e-48))) tmp = (l * (t ^ -3.0)) * (l / (k * k)); else tmp = (l / t) * ((2.0 * l) / (k ^ 4.0)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -3.8e-35], N[Not[LessEqual[t, 4.8e-48]], $MachinePrecision]], N[(N[(l * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision] * N[(l / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l / t), $MachinePrecision] * N[(N[(2.0 * l), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.8 \cdot 10^{-35} \lor \neg \left(t \leq 4.8 \cdot 10^{-48}\right):\\
\;\;\;\;\left(\ell \cdot {t}^{-3}\right) \cdot \frac{\ell}{k \cdot k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\ell}{t} \cdot \frac{2 \cdot \ell}{{k}^{4}}\\
\end{array}
\end{array}
if t < -3.8000000000000001e-35 or 4.8e-48 < t Initial program 67.9%
associate-/l/67.8%
associate-*l/67.8%
associate-*l/67.8%
associate-/r/67.1%
*-commutative67.1%
associate-/l/67.2%
associate-*r*67.2%
*-commutative67.2%
associate-*r*67.2%
*-commutative67.2%
Simplified67.2%
Taylor expanded in k around 0 58.6%
unpow258.6%
*-commutative58.6%
times-frac63.0%
unpow263.0%
Simplified63.0%
expm1-log1p-u57.9%
expm1-udef52.5%
div-inv52.5%
pow-flip52.5%
metadata-eval52.5%
Applied egg-rr52.5%
expm1-def58.4%
expm1-log1p63.5%
Simplified63.5%
if -3.8000000000000001e-35 < t < 4.8e-48Initial program 33.0%
associate-/l/33.0%
associate-*l/32.9%
associate-*l/32.9%
associate-/r/33.8%
*-commutative33.8%
associate-/l/33.8%
associate-*r*34.2%
*-commutative34.2%
associate-*r*34.2%
*-commutative34.2%
Simplified34.2%
Taylor expanded in k around inf 77.8%
unpow277.8%
*-commutative77.8%
Simplified77.8%
associate-*r/77.8%
Applied egg-rr77.8%
unpow277.8%
associate-*r/77.8%
unpow277.8%
associate-*l*83.0%
associate-*l*91.4%
*-commutative91.4%
Simplified91.4%
Taylor expanded in k around 0 59.0%
associate-*r/59.0%
*-commutative59.0%
unpow259.0%
associate-*l*59.0%
*-commutative59.0%
times-frac65.3%
*-commutative65.3%
Simplified65.3%
Final simplification64.3%
(FPCore (t l k) :precision binary64 (if (or (<= t -6.6e-37) (not (<= t 6.4e-41))) (* (/ l k) (/ l (* k (pow t 3.0)))) (* (/ l t) (/ (* 2.0 l) (pow k 4.0)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -6.6e-37) || !(t <= 6.4e-41)) {
tmp = (l / k) * (l / (k * pow(t, 3.0)));
} else {
tmp = (l / t) * ((2.0 * l) / pow(k, 4.0));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((t <= (-6.6d-37)) .or. (.not. (t <= 6.4d-41))) then
tmp = (l / k) * (l / (k * (t ** 3.0d0)))
else
tmp = (l / t) * ((2.0d0 * l) / (k ** 4.0d0))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -6.6e-37) || !(t <= 6.4e-41)) {
tmp = (l / k) * (l / (k * Math.pow(t, 3.0)));
} else {
tmp = (l / t) * ((2.0 * l) / Math.pow(k, 4.0));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -6.6e-37) or not (t <= 6.4e-41): tmp = (l / k) * (l / (k * math.pow(t, 3.0))) else: tmp = (l / t) * ((2.0 * l) / math.pow(k, 4.0)) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -6.6e-37) || !(t <= 6.4e-41)) tmp = Float64(Float64(l / k) * Float64(l / Float64(k * (t ^ 3.0)))); else tmp = Float64(Float64(l / t) * Float64(Float64(2.0 * l) / (k ^ 4.0))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -6.6e-37) || ~((t <= 6.4e-41))) tmp = (l / k) * (l / (k * (t ^ 3.0))); else tmp = (l / t) * ((2.0 * l) / (k ^ 4.0)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -6.6e-37], N[Not[LessEqual[t, 6.4e-41]], $MachinePrecision]], N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l / t), $MachinePrecision] * N[(N[(2.0 * l), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -6.6 \cdot 10^{-37} \lor \neg \left(t \leq 6.4 \cdot 10^{-41}\right):\\
\;\;\;\;\frac{\ell}{k} \cdot \frac{\ell}{k \cdot {t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\ell}{t} \cdot \frac{2 \cdot \ell}{{k}^{4}}\\
\end{array}
\end{array}
if t < -6.59999999999999964e-37 or 6.40000000000000024e-41 < t Initial program 68.1%
associate-/l/68.1%
associate-*l/68.1%
associate-*l/68.0%
associate-/r/67.4%
*-commutative67.4%
associate-/l/67.4%
associate-*r*67.4%
*-commutative67.4%
associate-*r*67.4%
*-commutative67.4%
Simplified67.4%
Taylor expanded in k around 0 58.7%
unpow258.7%
*-commutative58.7%
times-frac63.1%
unpow263.1%
Simplified63.1%
Taylor expanded in l around 0 58.7%
unpow258.7%
*-commutative58.7%
unpow258.7%
associate-*r*64.6%
times-frac71.1%
Simplified71.1%
if -6.59999999999999964e-37 < t < 6.40000000000000024e-41Initial program 33.3%
associate-/l/33.3%
associate-*l/33.2%
associate-*l/33.2%
associate-/r/34.1%
*-commutative34.1%
associate-/l/34.1%
associate-*r*34.5%
*-commutative34.5%
associate-*r*34.5%
*-commutative34.5%
Simplified34.5%
Taylor expanded in k around inf 77.4%
unpow277.4%
*-commutative77.4%
Simplified77.4%
associate-*r/77.4%
Applied egg-rr77.4%
unpow277.4%
associate-*r/77.4%
unpow277.4%
associate-*l*82.4%
associate-*l*90.7%
*-commutative90.7%
Simplified90.7%
Taylor expanded in k around 0 58.9%
associate-*r/58.9%
*-commutative58.9%
unpow258.9%
associate-*l*58.9%
*-commutative58.9%
times-frac65.1%
*-commutative65.1%
Simplified65.1%
Final simplification68.4%
(FPCore (t l k) :precision binary64 (if (<= t 3.6e-47) (* l (* 2.0 (/ (/ l t) (pow k 4.0)))) (* (* l (pow t -3.0)) (/ l (* k k)))))
double code(double t, double l, double k) {
double tmp;
if (t <= 3.6e-47) {
tmp = l * (2.0 * ((l / t) / pow(k, 4.0)));
} else {
tmp = (l * pow(t, -3.0)) * (l / (k * k));
}
return tmp;
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (t <= 3.6d-47) then
tmp = l * (2.0d0 * ((l / t) / (k ** 4.0d0)))
else
tmp = (l * (t ** (-3.0d0))) * (l / (k * k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (t <= 3.6e-47) {
tmp = l * (2.0 * ((l / t) / Math.pow(k, 4.0)));
} else {
tmp = (l * Math.pow(t, -3.0)) * (l / (k * k));
}
return tmp;
}
def code(t, l, k): tmp = 0 if t <= 3.6e-47: tmp = l * (2.0 * ((l / t) / math.pow(k, 4.0))) else: tmp = (l * math.pow(t, -3.0)) * (l / (k * k)) return tmp
function code(t, l, k) tmp = 0.0 if (t <= 3.6e-47) tmp = Float64(l * Float64(2.0 * Float64(Float64(l / t) / (k ^ 4.0)))); else tmp = Float64(Float64(l * (t ^ -3.0)) * Float64(l / Float64(k * k))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (t <= 3.6e-47) tmp = l * (2.0 * ((l / t) / (k ^ 4.0))); else tmp = (l * (t ^ -3.0)) * (l / (k * k)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[t, 3.6e-47], N[(l * N[(2.0 * N[(N[(l / t), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision] * N[(l / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 3.6 \cdot 10^{-47}:\\
\;\;\;\;\ell \cdot \left(2 \cdot \frac{\frac{\ell}{t}}{{k}^{4}}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot {t}^{-3}\right) \cdot \frac{\ell}{k \cdot k}\\
\end{array}
\end{array}
if t < 3.59999999999999991e-47Initial program 46.6%
associate-/l/46.6%
associate-*l/46.6%
associate-*l/46.6%
associate-/r/46.6%
*-commutative46.6%
associate-/l/46.6%
associate-*r*46.9%
*-commutative46.9%
associate-*r*46.9%
*-commutative46.9%
Simplified46.9%
Taylor expanded in k around inf 71.0%
unpow271.0%
*-commutative71.0%
Simplified71.0%
associate-*r/71.0%
Applied egg-rr71.0%
unpow271.0%
associate-*r/71.0%
unpow271.0%
associate-*l*75.4%
associate-*l*80.6%
*-commutative80.6%
Simplified80.6%
Taylor expanded in k around 0 61.6%
*-commutative61.6%
associate-/r*63.0%
Simplified63.0%
if 3.59999999999999991e-47 < t Initial program 67.4%
associate-/l/67.3%
associate-*l/67.3%
associate-*l/67.2%
associate-/r/67.3%
*-commutative67.3%
associate-/l/67.3%
associate-*r*67.3%
*-commutative67.3%
associate-*r*67.3%
*-commutative67.3%
Simplified67.3%
Taylor expanded in k around 0 57.6%
unpow257.6%
*-commutative57.6%
times-frac61.8%
unpow261.8%
Simplified61.8%
expm1-log1p-u57.5%
expm1-udef50.9%
div-inv50.9%
pow-flip50.9%
metadata-eval50.9%
Applied egg-rr50.9%
expm1-def57.5%
expm1-log1p61.9%
Simplified61.9%
Final simplification62.7%
(FPCore (t l k) :precision binary64 (* 2.0 (/ (* l l) (* t (pow k 4.0)))))
double code(double t, double l, double k) {
return 2.0 * ((l * l) / (t * pow(k, 4.0)));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 * ((l * l) / (t * (k ** 4.0d0)))
end function
public static double code(double t, double l, double k) {
return 2.0 * ((l * l) / (t * Math.pow(k, 4.0)));
}
def code(t, l, k): return 2.0 * ((l * l) / (t * math.pow(k, 4.0)))
function code(t, l, k) return Float64(2.0 * Float64(Float64(l * l) / Float64(t * (k ^ 4.0)))) end
function tmp = code(t, l, k) tmp = 2.0 * ((l * l) / (t * (k ^ 4.0))); end
code[t_, l_, k_] := N[(2.0 * N[(N[(l * l), $MachinePrecision] / N[(t * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \frac{\ell \cdot \ell}{t \cdot {k}^{4}}
\end{array}
Initial program 52.5%
associate-/l/52.4%
associate-*l/52.4%
associate-*l/52.4%
associate-/r/52.4%
*-commutative52.4%
associate-/l/52.4%
associate-*r*52.6%
*-commutative52.6%
associate-*r*52.6%
*-commutative52.6%
Simplified52.6%
Taylor expanded in k around inf 67.0%
unpow267.0%
*-commutative67.0%
Simplified67.0%
Taylor expanded in k around 0 56.8%
unpow256.8%
*-commutative56.8%
Simplified56.8%
Final simplification56.8%
(FPCore (t l k) :precision binary64 (* 2.0 (/ (* l (/ l (pow k 4.0))) t)))
double code(double t, double l, double k) {
return 2.0 * ((l * (l / pow(k, 4.0))) / t);
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 * ((l * (l / (k ** 4.0d0))) / t)
end function
public static double code(double t, double l, double k) {
return 2.0 * ((l * (l / Math.pow(k, 4.0))) / t);
}
def code(t, l, k): return 2.0 * ((l * (l / math.pow(k, 4.0))) / t)
function code(t, l, k) return Float64(2.0 * Float64(Float64(l * Float64(l / (k ^ 4.0))) / t)) end
function tmp = code(t, l, k) tmp = 2.0 * ((l * (l / (k ^ 4.0))) / t); end
code[t_, l_, k_] := N[(2.0 * N[(N[(l * N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \frac{\ell \cdot \frac{\ell}{{k}^{4}}}{t}
\end{array}
Initial program 52.5%
associate-/l/52.4%
associate-*l/52.4%
associate-*l/52.4%
associate-/r/52.4%
*-commutative52.4%
associate-/l/52.4%
associate-*r*52.6%
*-commutative52.6%
associate-*r*52.6%
*-commutative52.6%
Simplified52.6%
Taylor expanded in k around inf 67.0%
unpow267.0%
*-commutative67.0%
Simplified67.0%
associate-*r/67.0%
Applied egg-rr67.0%
unpow267.0%
associate-*r/67.0%
unpow267.0%
associate-*l*70.7%
associate-*l*74.4%
*-commutative74.4%
Simplified74.4%
associate-*r/74.4%
Applied egg-rr74.4%
associate-*r*74.4%
associate-/r*76.6%
*-commutative76.6%
Simplified76.6%
Taylor expanded in k around 0 56.8%
unpow256.8%
*-commutative56.8%
associate-*r/59.6%
*-commutative59.6%
associate-/r*60.4%
associate-*r/60.4%
Simplified60.4%
Final simplification60.4%
(FPCore (t l k) :precision binary64 (* l (* 2.0 (/ (/ l t) (pow k 4.0)))))
double code(double t, double l, double k) {
return l * (2.0 * ((l / 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 * (2.0d0 * ((l / t) / (k ** 4.0d0)))
end function
public static double code(double t, double l, double k) {
return l * (2.0 * ((l / t) / Math.pow(k, 4.0)));
}
def code(t, l, k): return l * (2.0 * ((l / t) / math.pow(k, 4.0)))
function code(t, l, k) return Float64(l * Float64(2.0 * Float64(Float64(l / t) / (k ^ 4.0)))) end
function tmp = code(t, l, k) tmp = l * (2.0 * ((l / t) / (k ^ 4.0))); end
code[t_, l_, k_] := N[(l * N[(2.0 * N[(N[(l / t), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\ell \cdot \left(2 \cdot \frac{\frac{\ell}{t}}{{k}^{4}}\right)
\end{array}
Initial program 52.5%
associate-/l/52.4%
associate-*l/52.4%
associate-*l/52.4%
associate-/r/52.4%
*-commutative52.4%
associate-/l/52.4%
associate-*r*52.6%
*-commutative52.6%
associate-*r*52.6%
*-commutative52.6%
Simplified52.6%
Taylor expanded in k around inf 67.0%
unpow267.0%
*-commutative67.0%
Simplified67.0%
associate-*r/67.0%
Applied egg-rr67.0%
unpow267.0%
associate-*r/67.0%
unpow267.0%
associate-*l*70.7%
associate-*l*74.4%
*-commutative74.4%
Simplified74.4%
Taylor expanded in k around 0 59.6%
*-commutative59.6%
associate-/r*60.6%
Simplified60.6%
Final simplification60.6%
herbie shell --seed 2023182
(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))))