
(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 23 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}
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= t_m 7e-93)
(/
2.0
(* (/ (* t_m (pow k 2.0)) (pow l 2.0)) (/ (pow (sin k) 2.0) (cos k))))
(/
2.0
(*
(pow (* (cbrt (sin k)) (/ t_m (pow (cbrt l) 2.0))) 3.0)
(* (tan k) (+ 2.0 (pow (/ k t_m) 2.0))))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 7e-93) {
tmp = 2.0 / (((t_m * pow(k, 2.0)) / pow(l, 2.0)) * (pow(sin(k), 2.0) / cos(k)));
} else {
tmp = 2.0 / (pow((cbrt(sin(k)) * (t_m / pow(cbrt(l), 2.0))), 3.0) * (tan(k) * (2.0 + pow((k / t_m), 2.0))));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 7e-93) {
tmp = 2.0 / (((t_m * Math.pow(k, 2.0)) / Math.pow(l, 2.0)) * (Math.pow(Math.sin(k), 2.0) / Math.cos(k)));
} else {
tmp = 2.0 / (Math.pow((Math.cbrt(Math.sin(k)) * (t_m / Math.pow(Math.cbrt(l), 2.0))), 3.0) * (Math.tan(k) * (2.0 + Math.pow((k / t_m), 2.0))));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (t_m <= 7e-93) tmp = Float64(2.0 / Float64(Float64(Float64(t_m * (k ^ 2.0)) / (l ^ 2.0)) * Float64((sin(k) ^ 2.0) / cos(k)))); else tmp = Float64(2.0 / Float64((Float64(cbrt(sin(k)) * Float64(t_m / (cbrt(l) ^ 2.0))) ^ 3.0) * Float64(tan(k) * Float64(2.0 + (Float64(k / t_m) ^ 2.0))))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[t$95$m, 7e-93], N[(2.0 / N[(N[(N[(t$95$m * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision] * N[(t$95$m / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 7 \cdot 10^{-93}:\\
\;\;\;\;\frac{2}{\frac{t\_m \cdot {k}^{2}}{{\ell}^{2}} \cdot \frac{{\sin k}^{2}}{\cos k}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\sqrt[3]{\sin k} \cdot \frac{t\_m}{{\left(\sqrt[3]{\ell}\right)}^{2}}\right)}^{3} \cdot \left(\tan k \cdot \left(2 + {\left(\frac{k}{t\_m}\right)}^{2}\right)\right)}\\
\end{array}
\end{array}
if t < 7e-93Initial program 53.1%
associate-*l*53.6%
sqr-neg53.6%
sqr-neg53.6%
associate-/r*57.6%
distribute-rgt-in57.6%
unpow257.6%
times-frac41.6%
sqr-neg41.6%
times-frac57.6%
unpow257.6%
distribute-rgt-in57.6%
Simplified57.6%
Taylor expanded in t around 0 71.3%
associate-*r*71.3%
times-frac71.4%
Simplified71.4%
if 7e-93 < t Initial program 65.6%
associate-*l*65.6%
sqr-neg65.6%
sqr-neg65.6%
associate-/r*72.7%
distribute-rgt-in72.7%
unpow272.7%
times-frac62.8%
sqr-neg62.8%
times-frac72.7%
unpow272.7%
distribute-rgt-in72.7%
Simplified72.7%
associate-/r*65.6%
add-cube-cbrt65.5%
pow365.5%
associate-/r*72.5%
*-commutative72.5%
cbrt-prod72.5%
associate-/r*65.4%
cbrt-div68.9%
rem-cbrt-cube76.5%
cbrt-prod88.8%
pow288.8%
Applied egg-rr88.8%
Final simplification76.9%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(let* ((t_2 (pow (/ k t_m) 2.0)))
(*
t_s
(if (<=
(*
(* (tan k) (* (sin k) (/ (pow t_m 3.0) (* l l))))
(+ 1.0 (+ t_2 1.0)))
5e+260)
(/ 2.0 (* (* (tan k) (+ 2.0 t_2)) (/ (* (sin k) (/ (pow t_m 3.0) l)) l)))
(/
2.0
(* (pow (/ (cbrt k) (/ (pow (cbrt l) 2.0) t_m)) 3.0) (* 2.0 k)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double t_2 = pow((k / t_m), 2.0);
double tmp;
if (((tan(k) * (sin(k) * (pow(t_m, 3.0) / (l * l)))) * (1.0 + (t_2 + 1.0))) <= 5e+260) {
tmp = 2.0 / ((tan(k) * (2.0 + t_2)) * ((sin(k) * (pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (pow((cbrt(k) / (pow(cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double t_2 = Math.pow((k / t_m), 2.0);
double tmp;
if (((Math.tan(k) * (Math.sin(k) * (Math.pow(t_m, 3.0) / (l * l)))) * (1.0 + (t_2 + 1.0))) <= 5e+260) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + t_2)) * ((Math.sin(k) * (Math.pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (Math.pow((Math.cbrt(k) / (Math.pow(Math.cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) t_2 = Float64(k / t_m) ^ 2.0 tmp = 0.0 if (Float64(Float64(tan(k) * Float64(sin(k) * Float64((t_m ^ 3.0) / Float64(l * l)))) * Float64(1.0 + Float64(t_2 + 1.0))) <= 5e+260) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + t_2)) * Float64(Float64(sin(k) * Float64((t_m ^ 3.0) / l)) / l))); else tmp = Float64(2.0 / Float64((Float64(cbrt(k) / Float64((cbrt(l) ^ 2.0) / t_m)) ^ 3.0) * Float64(2.0 * k))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := Block[{t$95$2 = N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 5e+260], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + t$95$2), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[Power[k, 1/3], $MachinePrecision] / N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := {\left(\frac{k}{t\_m}\right)}^{2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\left(\tan k \cdot \left(\sin k \cdot \frac{{t\_m}^{3}}{\ell \cdot \ell}\right)\right) \cdot \left(1 + \left(t\_2 + 1\right)\right) \leq 5 \cdot 10^{+260}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + t\_2\right)\right) \cdot \frac{\sin k \cdot \frac{{t\_m}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k}}{\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t\_m}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1)) < 4.9999999999999996e260Initial program 87.6%
associate-*l*88.4%
sqr-neg88.4%
sqr-neg88.4%
associate-/r*90.4%
distribute-rgt-in90.4%
unpow290.4%
times-frac71.8%
sqr-neg71.8%
times-frac90.4%
unpow290.4%
distribute-rgt-in90.4%
Simplified90.4%
associate-*l/91.2%
Applied egg-rr91.2%
if 4.9999999999999996e260 < (*.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 28.8%
*-commutative28.8%
sqr-neg28.8%
*-commutative28.8%
associate-*l*28.8%
*-commutative28.8%
sqr-neg28.8%
Simplified28.8%
Taylor expanded in k around 0 37.8%
*-commutative37.8%
Simplified37.8%
Taylor expanded in k around 0 39.8%
associate-/l*37.6%
Simplified37.6%
add-cube-cbrt37.6%
pow237.6%
cbrt-div37.6%
unpow237.6%
cbrt-prod37.6%
pow237.6%
unpow337.6%
add-cbrt-cube37.6%
cbrt-div37.6%
unpow237.6%
cbrt-prod45.5%
pow245.5%
unpow345.5%
add-cbrt-cube57.2%
Applied egg-rr57.2%
pow-plus57.2%
metadata-eval57.2%
Simplified57.2%
add-cube-cbrt57.2%
pow357.2%
cbrt-div57.2%
rem-cbrt-cube60.2%
Applied egg-rr60.2%
Final simplification75.1%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= t_m 2.6e-93)
(/
2.0
(* (/ (* t_m (pow k 2.0)) (pow l 2.0)) (/ (pow (sin k) 2.0) (cos k))))
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t_m) 2.0)))
(/ (pow (* (cbrt (sin k)) (/ t_m (cbrt l))) 3.0) l))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 2.6e-93) {
tmp = 2.0 / (((t_m * pow(k, 2.0)) / pow(l, 2.0)) * (pow(sin(k), 2.0) / cos(k)));
} else {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t_m), 2.0))) * (pow((cbrt(sin(k)) * (t_m / cbrt(l))), 3.0) / l));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 2.6e-93) {
tmp = 2.0 / (((t_m * Math.pow(k, 2.0)) / Math.pow(l, 2.0)) * (Math.pow(Math.sin(k), 2.0) / Math.cos(k)));
} else {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t_m), 2.0))) * (Math.pow((Math.cbrt(Math.sin(k)) * (t_m / Math.cbrt(l))), 3.0) / l));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (t_m <= 2.6e-93) tmp = Float64(2.0 / Float64(Float64(Float64(t_m * (k ^ 2.0)) / (l ^ 2.0)) * Float64((sin(k) ^ 2.0) / cos(k)))); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t_m) ^ 2.0))) * Float64((Float64(cbrt(sin(k)) * Float64(t_m / cbrt(l))) ^ 3.0) / l))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[t$95$m, 2.6e-93], N[(2.0 / N[(N[(N[(t$95$m * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision] * N[(t$95$m / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 2.6 \cdot 10^{-93}:\\
\;\;\;\;\frac{2}{\frac{t\_m \cdot {k}^{2}}{{\ell}^{2}} \cdot \frac{{\sin k}^{2}}{\cos k}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t\_m}\right)}^{2}\right)\right) \cdot \frac{{\left(\sqrt[3]{\sin k} \cdot \frac{t\_m}{\sqrt[3]{\ell}}\right)}^{3}}{\ell}}\\
\end{array}
\end{array}
if t < 2.5999999999999998e-93Initial program 53.1%
associate-*l*53.6%
sqr-neg53.6%
sqr-neg53.6%
associate-/r*57.6%
distribute-rgt-in57.6%
unpow257.6%
times-frac41.6%
sqr-neg41.6%
times-frac57.6%
unpow257.6%
distribute-rgt-in57.6%
Simplified57.6%
Taylor expanded in t around 0 71.3%
associate-*r*71.3%
times-frac71.4%
Simplified71.4%
if 2.5999999999999998e-93 < t Initial program 65.6%
associate-*l*65.6%
sqr-neg65.6%
sqr-neg65.6%
associate-/r*72.7%
distribute-rgt-in72.7%
unpow272.7%
times-frac62.8%
sqr-neg62.8%
times-frac72.7%
unpow272.7%
distribute-rgt-in72.7%
Simplified72.7%
associate-*l/75.1%
Applied egg-rr75.1%
add-cube-cbrt74.8%
pow374.8%
*-commutative74.8%
cbrt-prod74.8%
cbrt-div75.8%
rem-cbrt-cube85.4%
Applied egg-rr85.4%
Final simplification75.8%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= t_m 3.6e-93)
(/
2.0
(* (/ (* t_m (pow k 2.0)) (pow l 2.0)) (/ (pow (sin k) 2.0) (cos k))))
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t_m) 2.0)))
(pow (/ t_m (* (cbrt l) (cbrt (/ l (sin k))))) 3.0))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 3.6e-93) {
tmp = 2.0 / (((t_m * pow(k, 2.0)) / pow(l, 2.0)) * (pow(sin(k), 2.0) / cos(k)));
} else {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t_m), 2.0))) * pow((t_m / (cbrt(l) * cbrt((l / sin(k))))), 3.0));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 3.6e-93) {
tmp = 2.0 / (((t_m * Math.pow(k, 2.0)) / Math.pow(l, 2.0)) * (Math.pow(Math.sin(k), 2.0) / Math.cos(k)));
} else {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t_m), 2.0))) * Math.pow((t_m / (Math.cbrt(l) * Math.cbrt((l / Math.sin(k))))), 3.0));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (t_m <= 3.6e-93) tmp = Float64(2.0 / Float64(Float64(Float64(t_m * (k ^ 2.0)) / (l ^ 2.0)) * Float64((sin(k) ^ 2.0) / cos(k)))); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t_m) ^ 2.0))) * (Float64(t_m / Float64(cbrt(l) * cbrt(Float64(l / sin(k))))) ^ 3.0))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[t$95$m, 3.6e-93], N[(2.0 / N[(N[(N[(t$95$m * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[(t$95$m / N[(N[Power[l, 1/3], $MachinePrecision] * N[Power[N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 3.6 \cdot 10^{-93}:\\
\;\;\;\;\frac{2}{\frac{t\_m \cdot {k}^{2}}{{\ell}^{2}} \cdot \frac{{\sin k}^{2}}{\cos k}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t\_m}\right)}^{2}\right)\right) \cdot {\left(\frac{t\_m}{\sqrt[3]{\ell} \cdot \sqrt[3]{\frac{\ell}{\sin k}}}\right)}^{3}}\\
\end{array}
\end{array}
if t < 3.6000000000000002e-93Initial program 53.1%
associate-*l*53.6%
sqr-neg53.6%
sqr-neg53.6%
associate-/r*57.6%
distribute-rgt-in57.6%
unpow257.6%
times-frac41.6%
sqr-neg41.6%
times-frac57.6%
unpow257.6%
distribute-rgt-in57.6%
Simplified57.6%
Taylor expanded in t around 0 71.3%
associate-*r*71.3%
times-frac71.4%
Simplified71.4%
if 3.6000000000000002e-93 < t Initial program 65.6%
associate-*l*65.6%
sqr-neg65.6%
sqr-neg65.6%
associate-/r*72.7%
distribute-rgt-in72.7%
unpow272.7%
times-frac62.8%
sqr-neg62.8%
times-frac72.7%
unpow272.7%
distribute-rgt-in72.7%
Simplified72.7%
associate-/r*65.6%
add-cube-cbrt65.5%
pow365.5%
associate-/r*72.5%
*-commutative72.5%
cbrt-prod72.5%
associate-/r*65.4%
cbrt-div68.9%
rem-cbrt-cube76.5%
cbrt-prod88.8%
pow288.8%
Applied egg-rr88.8%
rem-cbrt-cube75.8%
unpow275.8%
cbrt-prod68.9%
cbrt-div65.4%
cbrt-prod65.5%
associate-/r*72.5%
cube-mult72.6%
unpow272.6%
associate-*r/77.4%
/-rgt-identity77.4%
*-commutative77.4%
associate-*l/79.7%
/-rgt-identity79.7%
associate-*r/74.9%
unpow274.9%
cube-mult74.9%
Applied egg-rr84.3%
associate-/l/84.3%
Simplified84.3%
Final simplification75.5%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= t_m 2.7e-93)
(*
2.0
(/ (* (pow l 2.0) (cos k)) (* (pow k 2.0) (* t_m (pow (sin k) 2.0)))))
(if (<= t_m 6e+81)
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t_m) 2.0)))
(/ (* (sin k) (/ (pow t_m 3.0) l)) l)))
(/
2.0
(* (pow (/ (cbrt k) (/ (pow (cbrt l) 2.0) t_m)) 3.0) (* 2.0 k)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 2.7e-93) {
tmp = 2.0 * ((pow(l, 2.0) * cos(k)) / (pow(k, 2.0) * (t_m * pow(sin(k), 2.0))));
} else if (t_m <= 6e+81) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t_m), 2.0))) * ((sin(k) * (pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (pow((cbrt(k) / (pow(cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 2.7e-93) {
tmp = 2.0 * ((Math.pow(l, 2.0) * Math.cos(k)) / (Math.pow(k, 2.0) * (t_m * Math.pow(Math.sin(k), 2.0))));
} else if (t_m <= 6e+81) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t_m), 2.0))) * ((Math.sin(k) * (Math.pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (Math.pow((Math.cbrt(k) / (Math.pow(Math.cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (t_m <= 2.7e-93) tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) * cos(k)) / Float64((k ^ 2.0) * Float64(t_m * (sin(k) ^ 2.0))))); elseif (t_m <= 6e+81) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t_m) ^ 2.0))) * Float64(Float64(sin(k) * Float64((t_m ^ 3.0) / l)) / l))); else tmp = Float64(2.0 / Float64((Float64(cbrt(k) / Float64((cbrt(l) ^ 2.0) / t_m)) ^ 3.0) * Float64(2.0 * k))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[t$95$m, 2.7e-93], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[(N[Power[k, 2.0], $MachinePrecision] * N[(t$95$m * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 6e+81], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[Power[k, 1/3], $MachinePrecision] / N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 2.7 \cdot 10^{-93}:\\
\;\;\;\;2 \cdot \frac{{\ell}^{2} \cdot \cos k}{{k}^{2} \cdot \left(t\_m \cdot {\sin k}^{2}\right)}\\
\mathbf{elif}\;t\_m \leq 6 \cdot 10^{+81}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t\_m}\right)}^{2}\right)\right) \cdot \frac{\sin k \cdot \frac{{t\_m}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k}}{\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t\_m}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 2.7000000000000001e-93Initial program 53.1%
associate-/r*52.6%
sqr-neg52.6%
associate-*l*49.4%
sqr-neg49.4%
associate-/r*53.4%
associate-+l+53.4%
unpow253.4%
times-frac37.4%
sqr-neg37.4%
times-frac53.4%
unpow253.4%
Simplified53.4%
Taylor expanded in t around 0 71.3%
if 2.7000000000000001e-93 < t < 5.99999999999999995e81Initial program 67.7%
associate-*l*67.7%
sqr-neg67.7%
sqr-neg67.7%
associate-/r*77.6%
distribute-rgt-in77.6%
unpow277.6%
times-frac74.9%
sqr-neg74.9%
times-frac77.6%
unpow277.6%
distribute-rgt-in77.6%
Simplified77.6%
associate-*l/83.1%
Applied egg-rr83.1%
if 5.99999999999999995e81 < t Initial program 64.1%
*-commutative64.1%
sqr-neg64.1%
*-commutative64.1%
associate-*l*64.1%
*-commutative64.1%
sqr-neg64.1%
Simplified64.1%
Taylor expanded in k around 0 64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in k around 0 66.1%
associate-/l*64.1%
Simplified64.1%
add-cube-cbrt64.1%
pow264.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod64.1%
pow264.1%
unpow364.1%
add-cbrt-cube64.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod69.0%
pow269.0%
unpow369.0%
add-cbrt-cube87.7%
Applied egg-rr87.7%
pow-plus87.7%
metadata-eval87.7%
Simplified87.7%
add-cube-cbrt87.7%
pow387.6%
cbrt-div87.8%
rem-cbrt-cube92.0%
Applied egg-rr92.0%
Final simplification76.6%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= t_m 6.8e-93)
(*
(/ 2.0 (* t_m (pow k 2.0)))
(/ (* (pow l 2.0) (cos k)) (pow (sin k) 2.0)))
(if (<= t_m 2.35e+82)
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t_m) 2.0)))
(/ (* (sin k) (/ (pow t_m 3.0) l)) l)))
(/
2.0
(* (pow (/ (cbrt k) (/ (pow (cbrt l) 2.0) t_m)) 3.0) (* 2.0 k)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 6.8e-93) {
tmp = (2.0 / (t_m * pow(k, 2.0))) * ((pow(l, 2.0) * cos(k)) / pow(sin(k), 2.0));
} else if (t_m <= 2.35e+82) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t_m), 2.0))) * ((sin(k) * (pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (pow((cbrt(k) / (pow(cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 6.8e-93) {
tmp = (2.0 / (t_m * Math.pow(k, 2.0))) * ((Math.pow(l, 2.0) * Math.cos(k)) / Math.pow(Math.sin(k), 2.0));
} else if (t_m <= 2.35e+82) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t_m), 2.0))) * ((Math.sin(k) * (Math.pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (Math.pow((Math.cbrt(k) / (Math.pow(Math.cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (t_m <= 6.8e-93) tmp = Float64(Float64(2.0 / Float64(t_m * (k ^ 2.0))) * Float64(Float64((l ^ 2.0) * cos(k)) / (sin(k) ^ 2.0))); elseif (t_m <= 2.35e+82) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t_m) ^ 2.0))) * Float64(Float64(sin(k) * Float64((t_m ^ 3.0) / l)) / l))); else tmp = Float64(2.0 / Float64((Float64(cbrt(k) / Float64((cbrt(l) ^ 2.0) / t_m)) ^ 3.0) * Float64(2.0 * k))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[t$95$m, 6.8e-93], N[(N[(2.0 / N[(t$95$m * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 2.35e+82], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[Power[k, 1/3], $MachinePrecision] / N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 6.8 \cdot 10^{-93}:\\
\;\;\;\;\frac{2}{t\_m \cdot {k}^{2}} \cdot \frac{{\ell}^{2} \cdot \cos k}{{\sin k}^{2}}\\
\mathbf{elif}\;t\_m \leq 2.35 \cdot 10^{+82}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t\_m}\right)}^{2}\right)\right) \cdot \frac{\sin k \cdot \frac{{t\_m}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k}}{\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t\_m}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 6.80000000000000002e-93Initial program 53.1%
associate-*l*53.6%
sqr-neg53.6%
sqr-neg53.6%
associate-/r*57.6%
distribute-rgt-in57.6%
unpow257.6%
times-frac41.6%
sqr-neg41.6%
times-frac57.6%
unpow257.6%
distribute-rgt-in57.6%
Simplified57.6%
associate-/r*53.6%
add-cube-cbrt53.5%
pow353.5%
associate-/r*57.5%
*-commutative57.5%
cbrt-prod57.5%
associate-/r*53.5%
cbrt-div53.5%
rem-cbrt-cube63.2%
cbrt-prod69.8%
pow269.8%
Applied egg-rr69.8%
Applied egg-rr66.6%
cube-prod63.6%
rem-cube-cbrt63.7%
Simplified63.7%
Taylor expanded in t around 0 71.3%
associate-*r/71.3%
associate-*r*71.3%
times-frac71.3%
Simplified71.3%
if 6.80000000000000002e-93 < t < 2.35e82Initial program 67.7%
associate-*l*67.7%
sqr-neg67.7%
sqr-neg67.7%
associate-/r*77.6%
distribute-rgt-in77.6%
unpow277.6%
times-frac74.9%
sqr-neg74.9%
times-frac77.6%
unpow277.6%
distribute-rgt-in77.6%
Simplified77.6%
associate-*l/83.1%
Applied egg-rr83.1%
if 2.35e82 < t Initial program 64.1%
*-commutative64.1%
sqr-neg64.1%
*-commutative64.1%
associate-*l*64.1%
*-commutative64.1%
sqr-neg64.1%
Simplified64.1%
Taylor expanded in k around 0 64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in k around 0 66.1%
associate-/l*64.1%
Simplified64.1%
add-cube-cbrt64.1%
pow264.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod64.1%
pow264.1%
unpow364.1%
add-cbrt-cube64.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod69.0%
pow269.0%
unpow369.0%
add-cbrt-cube87.7%
Applied egg-rr87.7%
pow-plus87.7%
metadata-eval87.7%
Simplified87.7%
add-cube-cbrt87.7%
pow387.6%
cbrt-div87.8%
rem-cbrt-cube92.0%
Applied egg-rr92.0%
Final simplification76.7%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= t_m 3.7e-93)
(/
2.0
(* (/ (* t_m (pow k 2.0)) (pow l 2.0)) (/ (pow (sin k) 2.0) (cos k))))
(if (<= t_m 2.55e+82)
(/
2.0
(*
(* (tan k) (+ 2.0 (pow (/ k t_m) 2.0)))
(/ (* (sin k) (/ (pow t_m 3.0) l)) l)))
(/
2.0
(* (pow (/ (cbrt k) (/ (pow (cbrt l) 2.0) t_m)) 3.0) (* 2.0 k)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 3.7e-93) {
tmp = 2.0 / (((t_m * pow(k, 2.0)) / pow(l, 2.0)) * (pow(sin(k), 2.0) / cos(k)));
} else if (t_m <= 2.55e+82) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t_m), 2.0))) * ((sin(k) * (pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (pow((cbrt(k) / (pow(cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (t_m <= 3.7e-93) {
tmp = 2.0 / (((t_m * Math.pow(k, 2.0)) / Math.pow(l, 2.0)) * (Math.pow(Math.sin(k), 2.0) / Math.cos(k)));
} else if (t_m <= 2.55e+82) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t_m), 2.0))) * ((Math.sin(k) * (Math.pow(t_m, 3.0) / l)) / l));
} else {
tmp = 2.0 / (Math.pow((Math.cbrt(k) / (Math.pow(Math.cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (t_m <= 3.7e-93) tmp = Float64(2.0 / Float64(Float64(Float64(t_m * (k ^ 2.0)) / (l ^ 2.0)) * Float64((sin(k) ^ 2.0) / cos(k)))); elseif (t_m <= 2.55e+82) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t_m) ^ 2.0))) * Float64(Float64(sin(k) * Float64((t_m ^ 3.0) / l)) / l))); else tmp = Float64(2.0 / Float64((Float64(cbrt(k) / Float64((cbrt(l) ^ 2.0) / t_m)) ^ 3.0) * Float64(2.0 * k))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[t$95$m, 3.7e-93], N[(2.0 / N[(N[(N[(t$95$m * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 2.55e+82], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[Power[k, 1/3], $MachinePrecision] / N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 3.7 \cdot 10^{-93}:\\
\;\;\;\;\frac{2}{\frac{t\_m \cdot {k}^{2}}{{\ell}^{2}} \cdot \frac{{\sin k}^{2}}{\cos k}}\\
\mathbf{elif}\;t\_m \leq 2.55 \cdot 10^{+82}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t\_m}\right)}^{2}\right)\right) \cdot \frac{\sin k \cdot \frac{{t\_m}^{3}}{\ell}}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k}}{\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t\_m}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
if t < 3.70000000000000002e-93Initial program 53.1%
associate-*l*53.6%
sqr-neg53.6%
sqr-neg53.6%
associate-/r*57.6%
distribute-rgt-in57.6%
unpow257.6%
times-frac41.6%
sqr-neg41.6%
times-frac57.6%
unpow257.6%
distribute-rgt-in57.6%
Simplified57.6%
Taylor expanded in t around 0 71.3%
associate-*r*71.3%
times-frac71.4%
Simplified71.4%
if 3.70000000000000002e-93 < t < 2.5500000000000001e82Initial program 67.7%
associate-*l*67.7%
sqr-neg67.7%
sqr-neg67.7%
associate-/r*77.6%
distribute-rgt-in77.6%
unpow277.6%
times-frac74.9%
sqr-neg74.9%
times-frac77.6%
unpow277.6%
distribute-rgt-in77.6%
Simplified77.6%
associate-*l/83.1%
Applied egg-rr83.1%
if 2.5500000000000001e82 < t Initial program 64.1%
*-commutative64.1%
sqr-neg64.1%
*-commutative64.1%
associate-*l*64.1%
*-commutative64.1%
sqr-neg64.1%
Simplified64.1%
Taylor expanded in k around 0 64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in k around 0 66.1%
associate-/l*64.1%
Simplified64.1%
add-cube-cbrt64.1%
pow264.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod64.1%
pow264.1%
unpow364.1%
add-cbrt-cube64.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod69.0%
pow269.0%
unpow369.0%
add-cbrt-cube87.7%
Applied egg-rr87.7%
pow-plus87.7%
metadata-eval87.7%
Simplified87.7%
add-cube-cbrt87.7%
pow387.6%
cbrt-div87.8%
rem-cbrt-cube92.0%
Applied egg-rr92.0%
Final simplification76.7%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(let* ((t_2 (* (sin k) (/ (/ (pow t_m 3.0) l) l))))
(*
t_s
(if (<= t_m 4.2e-240)
(/ 2.0 (/ (* 2.0 t_2) (/ 1.0 (tan k))))
(if (<= t_m 1.35e-108)
(/ 2.0 (* (* 2.0 k) (pow (* t_m (cbrt (/ k (pow l 2.0)))) 3.0)))
(if (<= t_m 2.3e+82)
(/ 2.0 (* (* (tan k) (+ 2.0 (pow (/ k t_m) 2.0))) t_2))
(/
2.0
(*
(pow (/ (cbrt k) (/ (pow (cbrt l) 2.0) t_m)) 3.0)
(* 2.0 k)))))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double t_2 = sin(k) * ((pow(t_m, 3.0) / l) / l);
double tmp;
if (t_m <= 4.2e-240) {
tmp = 2.0 / ((2.0 * t_2) / (1.0 / tan(k)));
} else if (t_m <= 1.35e-108) {
tmp = 2.0 / ((2.0 * k) * pow((t_m * cbrt((k / pow(l, 2.0)))), 3.0));
} else if (t_m <= 2.3e+82) {
tmp = 2.0 / ((tan(k) * (2.0 + pow((k / t_m), 2.0))) * t_2);
} else {
tmp = 2.0 / (pow((cbrt(k) / (pow(cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double t_2 = Math.sin(k) * ((Math.pow(t_m, 3.0) / l) / l);
double tmp;
if (t_m <= 4.2e-240) {
tmp = 2.0 / ((2.0 * t_2) / (1.0 / Math.tan(k)));
} else if (t_m <= 1.35e-108) {
tmp = 2.0 / ((2.0 * k) * Math.pow((t_m * Math.cbrt((k / Math.pow(l, 2.0)))), 3.0));
} else if (t_m <= 2.3e+82) {
tmp = 2.0 / ((Math.tan(k) * (2.0 + Math.pow((k / t_m), 2.0))) * t_2);
} else {
tmp = 2.0 / (Math.pow((Math.cbrt(k) / (Math.pow(Math.cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) t_2 = Float64(sin(k) * Float64(Float64((t_m ^ 3.0) / l) / l)) tmp = 0.0 if (t_m <= 4.2e-240) tmp = Float64(2.0 / Float64(Float64(2.0 * t_2) / Float64(1.0 / tan(k)))); elseif (t_m <= 1.35e-108) tmp = Float64(2.0 / Float64(Float64(2.0 * k) * (Float64(t_m * cbrt(Float64(k / (l ^ 2.0)))) ^ 3.0))); elseif (t_m <= 2.3e+82) tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(2.0 + (Float64(k / t_m) ^ 2.0))) * t_2)); else tmp = Float64(2.0 / Float64((Float64(cbrt(k) / Float64((cbrt(l) ^ 2.0) / t_m)) ^ 3.0) * Float64(2.0 * k))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := Block[{t$95$2 = N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$m, 4.2e-240], N[(2.0 / N[(N[(2.0 * t$95$2), $MachinePrecision] / N[(1.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 1.35e-108], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[Power[N[(t$95$m * N[Power[N[(k / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 2.3e+82], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[Power[N[(N[Power[k, 1/3], $MachinePrecision] / N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \sin k \cdot \frac{\frac{{t\_m}^{3}}{\ell}}{\ell}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 4.2 \cdot 10^{-240}:\\
\;\;\;\;\frac{2}{\frac{2 \cdot t\_2}{\frac{1}{\tan k}}}\\
\mathbf{elif}\;t\_m \leq 1.35 \cdot 10^{-108}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot {\left(t\_m \cdot \sqrt[3]{\frac{k}{{\ell}^{2}}}\right)}^{3}}\\
\mathbf{elif}\;t\_m \leq 2.3 \cdot 10^{+82}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(2 + {\left(\frac{k}{t\_m}\right)}^{2}\right)\right) \cdot t\_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k}}{\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t\_m}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\end{array}
\end{array}
\end{array}
if t < 4.19999999999999987e-240Initial program 55.3%
associate-*l*56.0%
sqr-neg56.0%
sqr-neg56.0%
associate-/r*61.0%
distribute-rgt-in61.0%
unpow261.0%
times-frac46.7%
sqr-neg46.7%
times-frac61.0%
unpow261.0%
distribute-rgt-in61.0%
Simplified61.0%
cube-mult61.0%
*-un-lft-identity61.0%
times-frac68.8%
pow268.8%
Applied egg-rr68.8%
Taylor expanded in t around inf 63.0%
associate-*r/63.0%
associate-/l*63.0%
Simplified63.0%
associate-*r/63.0%
*-commutative63.0%
frac-times60.2%
unpow260.2%
cube-mult60.2%
*-un-lft-identity60.2%
clear-num60.2%
tan-quot60.2%
Applied egg-rr60.2%
if 4.19999999999999987e-240 < t < 1.35000000000000002e-108Initial program 35.9%
*-commutative35.9%
sqr-neg35.9%
*-commutative35.9%
associate-*l*35.9%
*-commutative35.9%
sqr-neg35.9%
Simplified35.9%
Taylor expanded in k around 0 51.2%
*-commutative51.2%
Simplified51.2%
Taylor expanded in k around 0 47.6%
associate-/l*47.6%
Simplified47.6%
add-cube-cbrt47.6%
pow347.6%
associate-/r/47.5%
cbrt-prod47.5%
unpow347.5%
add-cbrt-cube62.0%
Applied egg-rr62.0%
if 1.35000000000000002e-108 < t < 2.29999999999999988e82Initial program 69.0%
associate-*l*69.0%
sqr-neg69.0%
sqr-neg69.0%
associate-/r*77.0%
distribute-rgt-in77.0%
unpow277.0%
times-frac74.8%
sqr-neg74.8%
times-frac77.0%
unpow277.0%
distribute-rgt-in77.0%
Simplified77.0%
if 2.29999999999999988e82 < t Initial program 64.1%
*-commutative64.1%
sqr-neg64.1%
*-commutative64.1%
associate-*l*64.1%
*-commutative64.1%
sqr-neg64.1%
Simplified64.1%
Taylor expanded in k around 0 64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in k around 0 66.1%
associate-/l*64.1%
Simplified64.1%
add-cube-cbrt64.1%
pow264.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod64.1%
pow264.1%
unpow364.1%
add-cbrt-cube64.1%
cbrt-div64.1%
unpow264.1%
cbrt-prod69.0%
pow269.0%
unpow369.0%
add-cbrt-cube87.7%
Applied egg-rr87.7%
pow-plus87.7%
metadata-eval87.7%
Simplified87.7%
add-cube-cbrt87.7%
pow387.6%
cbrt-div87.8%
rem-cbrt-cube92.0%
Applied egg-rr92.0%
Final simplification68.9%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(let* ((t_2 (/ (pow (cbrt l) 2.0) t_m)))
(*
t_s
(if (<= k 3.5e-12)
(/ 2.0 (* (pow (/ (cbrt k) t_2) 3.0) (* 2.0 k)))
(if (<= k 2.5e+164)
(/
2.0
(/ (* 2.0 (* (sin k) (/ (/ (pow t_m 3.0) l) l))) (/ 1.0 (tan k))))
(/ 2.0 (pow (/ (cbrt (* k (* 2.0 k))) t_2) 3.0)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double t_2 = pow(cbrt(l), 2.0) / t_m;
double tmp;
if (k <= 3.5e-12) {
tmp = 2.0 / (pow((cbrt(k) / t_2), 3.0) * (2.0 * k));
} else if (k <= 2.5e+164) {
tmp = 2.0 / ((2.0 * (sin(k) * ((pow(t_m, 3.0) / l) / l))) / (1.0 / tan(k)));
} else {
tmp = 2.0 / pow((cbrt((k * (2.0 * k))) / t_2), 3.0);
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double t_2 = Math.pow(Math.cbrt(l), 2.0) / t_m;
double tmp;
if (k <= 3.5e-12) {
tmp = 2.0 / (Math.pow((Math.cbrt(k) / t_2), 3.0) * (2.0 * k));
} else if (k <= 2.5e+164) {
tmp = 2.0 / ((2.0 * (Math.sin(k) * ((Math.pow(t_m, 3.0) / l) / l))) / (1.0 / Math.tan(k)));
} else {
tmp = 2.0 / Math.pow((Math.cbrt((k * (2.0 * k))) / t_2), 3.0);
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) t_2 = Float64((cbrt(l) ^ 2.0) / t_m) tmp = 0.0 if (k <= 3.5e-12) tmp = Float64(2.0 / Float64((Float64(cbrt(k) / t_2) ^ 3.0) * Float64(2.0 * k))); elseif (k <= 2.5e+164) tmp = Float64(2.0 / Float64(Float64(2.0 * Float64(sin(k) * Float64(Float64((t_m ^ 3.0) / l) / l))) / Float64(1.0 / tan(k)))); else tmp = Float64(2.0 / (Float64(cbrt(Float64(k * Float64(2.0 * k))) / t_2) ^ 3.0)); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := Block[{t$95$2 = N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]}, N[(t$95$s * If[LessEqual[k, 3.5e-12], N[(2.0 / N[(N[Power[N[(N[Power[k, 1/3], $MachinePrecision] / t$95$2), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.5e+164], N[(2.0 / N[(N[(2.0 * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[Power[N[(N[Power[N[(k * N[(2.0 * k), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t$95$2), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k \leq 3.5 \cdot 10^{-12}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k}}{t\_2}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\mathbf{elif}\;k \leq 2.5 \cdot 10^{+164}:\\
\;\;\;\;\frac{2}{\frac{2 \cdot \left(\sin k \cdot \frac{\frac{{t\_m}^{3}}{\ell}}{\ell}\right)}{\frac{1}{\tan k}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k \cdot \left(2 \cdot k\right)}}{t\_2}\right)}^{3}}\\
\end{array}
\end{array}
\end{array}
if k < 3.5e-12Initial program 60.1%
*-commutative60.1%
sqr-neg60.1%
*-commutative60.1%
associate-*l*60.6%
*-commutative60.6%
sqr-neg60.6%
Simplified60.6%
Taylor expanded in k around 0 59.6%
*-commutative59.6%
Simplified59.6%
Taylor expanded in k around 0 61.1%
associate-/l*60.0%
Simplified60.0%
add-cube-cbrt59.9%
pow259.9%
cbrt-div59.9%
unpow259.9%
cbrt-prod59.9%
pow259.9%
unpow359.9%
add-cbrt-cube59.9%
cbrt-div59.9%
unpow259.9%
cbrt-prod64.6%
pow264.6%
unpow364.6%
add-cbrt-cube74.5%
Applied egg-rr74.5%
pow-plus74.5%
metadata-eval74.5%
Simplified74.5%
add-cube-cbrt74.5%
pow374.5%
cbrt-div74.4%
rem-cbrt-cube77.7%
Applied egg-rr77.7%
if 3.5e-12 < k < 2.49999999999999975e164Initial program 47.2%
associate-*l*47.2%
sqr-neg47.2%
sqr-neg47.2%
associate-/r*49.2%
distribute-rgt-in49.2%
unpow249.2%
times-frac44.5%
sqr-neg44.5%
times-frac49.2%
unpow249.2%
distribute-rgt-in49.2%
Simplified49.2%
cube-mult49.2%
*-un-lft-identity49.2%
times-frac49.2%
pow249.2%
Applied egg-rr49.2%
Taylor expanded in t around inf 63.5%
associate-*r/63.5%
associate-/l*63.5%
Simplified63.5%
associate-*r/63.5%
*-commutative63.5%
frac-times63.5%
unpow263.5%
cube-mult63.5%
*-un-lft-identity63.5%
clear-num63.5%
tan-quot63.5%
Applied egg-rr63.5%
if 2.49999999999999975e164 < k Initial program 51.7%
*-commutative51.7%
sqr-neg51.7%
*-commutative51.7%
associate-*l*51.7%
*-commutative51.7%
sqr-neg51.7%
Simplified51.7%
Taylor expanded in k around 0 42.8%
*-commutative42.8%
Simplified42.8%
Taylor expanded in k around 0 52.3%
associate-/l*52.2%
Simplified52.2%
add-cube-cbrt52.2%
pow352.2%
associate-*l/51.7%
cbrt-div51.7%
cbrt-div52.3%
unpow252.3%
cbrt-prod59.3%
pow259.3%
unpow359.3%
add-cbrt-cube74.0%
Applied egg-rr74.0%
Final simplification75.0%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 2.5e-12)
(/ 2.0 (* (pow (/ (cbrt k) (/ (pow (cbrt l) 2.0) t_m)) 3.0) (* 2.0 k)))
(if (<= k 4.7e+112)
(/ 2.0 (/ (* 2.0 (* (sin k) (/ (/ (pow t_m 3.0) l) l))) (/ 1.0 (tan k))))
(pow (/ (/ 1.0 (cbrt k)) (* t_m (cbrt (* k (pow l -2.0))))) 3.0)))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 2.5e-12) {
tmp = 2.0 / (pow((cbrt(k) / (pow(cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
} else if (k <= 4.7e+112) {
tmp = 2.0 / ((2.0 * (sin(k) * ((pow(t_m, 3.0) / l) / l))) / (1.0 / tan(k)));
} else {
tmp = pow(((1.0 / cbrt(k)) / (t_m * cbrt((k * pow(l, -2.0))))), 3.0);
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 2.5e-12) {
tmp = 2.0 / (Math.pow((Math.cbrt(k) / (Math.pow(Math.cbrt(l), 2.0) / t_m)), 3.0) * (2.0 * k));
} else if (k <= 4.7e+112) {
tmp = 2.0 / ((2.0 * (Math.sin(k) * ((Math.pow(t_m, 3.0) / l) / l))) / (1.0 / Math.tan(k)));
} else {
tmp = Math.pow(((1.0 / Math.cbrt(k)) / (t_m * Math.cbrt((k * Math.pow(l, -2.0))))), 3.0);
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (k <= 2.5e-12) tmp = Float64(2.0 / Float64((Float64(cbrt(k) / Float64((cbrt(l) ^ 2.0) / t_m)) ^ 3.0) * Float64(2.0 * k))); elseif (k <= 4.7e+112) tmp = Float64(2.0 / Float64(Float64(2.0 * Float64(sin(k) * Float64(Float64((t_m ^ 3.0) / l) / l))) / Float64(1.0 / tan(k)))); else tmp = Float64(Float64(1.0 / cbrt(k)) / Float64(t_m * cbrt(Float64(k * (l ^ -2.0))))) ^ 3.0; end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[k, 2.5e-12], N[(2.0 / N[(N[Power[N[(N[Power[k, 1/3], $MachinePrecision] / N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 4.7e+112], N[(2.0 / N[(N[(2.0 * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(1.0 / N[Power[k, 1/3], $MachinePrecision]), $MachinePrecision] / N[(t$95$m * N[Power[N[(k * N[Power[l, -2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k \leq 2.5 \cdot 10^{-12}:\\
\;\;\;\;\frac{2}{{\left(\frac{\sqrt[3]{k}}{\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t\_m}}\right)}^{3} \cdot \left(2 \cdot k\right)}\\
\mathbf{elif}\;k \leq 4.7 \cdot 10^{+112}:\\
\;\;\;\;\frac{2}{\frac{2 \cdot \left(\sin k \cdot \frac{\frac{{t\_m}^{3}}{\ell}}{\ell}\right)}{\frac{1}{\tan k}}}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\frac{1}{\sqrt[3]{k}}}{t\_m \cdot \sqrt[3]{k \cdot {\ell}^{-2}}}\right)}^{3}\\
\end{array}
\end{array}
if k < 2.49999999999999985e-12Initial program 60.1%
*-commutative60.1%
sqr-neg60.1%
*-commutative60.1%
associate-*l*60.6%
*-commutative60.6%
sqr-neg60.6%
Simplified60.6%
Taylor expanded in k around 0 59.6%
*-commutative59.6%
Simplified59.6%
Taylor expanded in k around 0 61.1%
associate-/l*60.0%
Simplified60.0%
add-cube-cbrt59.9%
pow259.9%
cbrt-div59.9%
unpow259.9%
cbrt-prod59.9%
pow259.9%
unpow359.9%
add-cbrt-cube59.9%
cbrt-div59.9%
unpow259.9%
cbrt-prod64.6%
pow264.6%
unpow364.6%
add-cbrt-cube74.5%
Applied egg-rr74.5%
pow-plus74.5%
metadata-eval74.5%
Simplified74.5%
add-cube-cbrt74.5%
pow374.5%
cbrt-div74.4%
rem-cbrt-cube77.7%
Applied egg-rr77.7%
if 2.49999999999999985e-12 < k < 4.69999999999999997e112Initial program 43.6%
associate-*l*43.6%
sqr-neg43.6%
sqr-neg43.6%
associate-/r*46.3%
distribute-rgt-in46.3%
unpow246.3%
times-frac46.3%
sqr-neg46.3%
times-frac46.3%
unpow246.3%
distribute-rgt-in46.3%
Simplified46.3%
cube-mult46.3%
*-un-lft-identity46.3%
times-frac46.3%
pow246.3%
Applied egg-rr46.3%
Taylor expanded in t around inf 64.1%
associate-*r/64.1%
associate-/l*64.1%
Simplified64.1%
associate-*r/64.1%
*-commutative64.1%
frac-times64.1%
unpow264.1%
cube-mult64.1%
*-un-lft-identity64.1%
clear-num64.1%
tan-quot64.1%
Applied egg-rr64.1%
if 4.69999999999999997e112 < k Initial program 53.6%
*-commutative53.6%
sqr-neg53.6%
*-commutative53.6%
associate-*l*53.6%
*-commutative53.6%
sqr-neg53.6%
Simplified53.6%
Taylor expanded in k around 0 44.8%
*-commutative44.8%
Simplified44.8%
Taylor expanded in k around 0 51.8%
associate-/l*51.7%
Simplified51.7%
div-inv51.7%
associate-/r/51.6%
Applied egg-rr51.6%
associate-*r/51.6%
metadata-eval51.6%
*-commutative51.6%
associate-/r*51.6%
*-commutative51.6%
associate-/r*51.6%
metadata-eval51.6%
*-commutative51.6%
Simplified51.6%
add-cube-cbrt51.6%
pow351.6%
cbrt-div51.6%
cbrt-div51.6%
metadata-eval51.6%
cbrt-prod51.7%
rem-cbrt-cube65.5%
div-inv65.5%
pow-flip65.5%
metadata-eval65.5%
Applied egg-rr65.5%
Final simplification74.2%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= l 1.6e+246)
(pow (/ (pow k -0.5) (* (pow t_m 1.5) (/ (sqrt k) l))) 2.0)
(/ 2.0 (* (* 2.0 k) (* (sin k) (pow (* t_m (pow (cbrt l) -2.0)) 3.0)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 1.6e+246) {
tmp = pow((pow(k, -0.5) / (pow(t_m, 1.5) * (sqrt(k) / l))), 2.0);
} else {
tmp = 2.0 / ((2.0 * k) * (sin(k) * pow((t_m * pow(cbrt(l), -2.0)), 3.0)));
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 1.6e+246) {
tmp = Math.pow((Math.pow(k, -0.5) / (Math.pow(t_m, 1.5) * (Math.sqrt(k) / l))), 2.0);
} else {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * Math.pow((t_m * Math.pow(Math.cbrt(l), -2.0)), 3.0)));
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (l <= 1.6e+246) tmp = Float64((k ^ -0.5) / Float64((t_m ^ 1.5) * Float64(sqrt(k) / l))) ^ 2.0; else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * (Float64(t_m * (cbrt(l) ^ -2.0)) ^ 3.0)))); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[l, 1.6e+246], N[Power[N[(N[Power[k, -0.5], $MachinePrecision] / N[(N[Power[t$95$m, 1.5], $MachinePrecision] * N[(N[Sqrt[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t$95$m * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\ell \leq 1.6 \cdot 10^{+246}:\\
\;\;\;\;{\left(\frac{{k}^{-0.5}}{{t\_m}^{1.5} \cdot \frac{\sqrt{k}}{\ell}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot {\left(t\_m \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right)}^{3}\right)}\\
\end{array}
\end{array}
if l < 1.60000000000000007e246Initial program 58.4%
*-commutative58.4%
sqr-neg58.4%
*-commutative58.4%
associate-*l*58.8%
*-commutative58.8%
sqr-neg58.8%
Simplified58.8%
Taylor expanded in k around 0 56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in k around 0 59.2%
associate-/l*58.2%
Simplified58.2%
div-inv58.2%
associate-/r/58.3%
Applied egg-rr58.3%
associate-*r/58.3%
metadata-eval58.3%
*-commutative58.3%
associate-/r*58.3%
*-commutative58.3%
associate-/r*58.3%
metadata-eval58.3%
*-commutative58.3%
Simplified58.3%
add-sqr-sqrt44.1%
sqrt-div16.3%
inv-pow16.3%
sqrt-pow116.3%
metadata-eval16.3%
sqrt-prod16.3%
sqrt-pow116.3%
metadata-eval16.3%
sqrt-div16.3%
unpow216.3%
sqrt-prod8.5%
add-sqr-sqrt13.4%
sqrt-div13.4%
inv-pow13.4%
sqrt-pow113.4%
metadata-eval13.4%
sqrt-prod13.4%
Applied egg-rr19.9%
unpow219.9%
Simplified19.9%
if 1.60000000000000007e246 < l Initial program 39.3%
*-commutative39.3%
sqr-neg39.3%
*-commutative39.3%
associate-*l*39.3%
*-commutative39.3%
sqr-neg39.3%
Simplified39.3%
Taylor expanded in k around 0 55.6%
*-commutative55.6%
Simplified55.6%
rem-cube-cbrt55.6%
cbrt-div55.6%
rem-cbrt-cube67.0%
cbrt-prod82.5%
unpow282.5%
div-inv82.5%
unpow-prod-down55.6%
pow-flip55.6%
metadata-eval55.6%
Applied egg-rr55.6%
cube-prod82.5%
Simplified82.5%
Final simplification24.3%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= l 2.8e+246)
(pow (/ (pow k -0.5) (* (pow t_m 1.5) (/ (sqrt k) l))) 2.0)
(/
2.0
(*
(* 2.0 k)
(* (sin k) (pow (* t_m (pow l -0.6666666666666666)) 3.0)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 2.8e+246) {
tmp = pow((pow(k, -0.5) / (pow(t_m, 1.5) * (sqrt(k) / l))), 2.0);
} else {
tmp = 2.0 / ((2.0 * k) * (sin(k) * pow((t_m * pow(l, -0.6666666666666666)), 3.0)));
}
return t_s * tmp;
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (l <= 2.8d+246) then
tmp = ((k ** (-0.5d0)) / ((t_m ** 1.5d0) * (sqrt(k) / l))) ** 2.0d0
else
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * ((t_m * (l ** (-0.6666666666666666d0))) ** 3.0d0)))
end if
code = t_s * tmp
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 2.8e+246) {
tmp = Math.pow((Math.pow(k, -0.5) / (Math.pow(t_m, 1.5) * (Math.sqrt(k) / l))), 2.0);
} else {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * Math.pow((t_m * Math.pow(l, -0.6666666666666666)), 3.0)));
}
return t_s * tmp;
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): tmp = 0 if l <= 2.8e+246: tmp = math.pow((math.pow(k, -0.5) / (math.pow(t_m, 1.5) * (math.sqrt(k) / l))), 2.0) else: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * math.pow((t_m * math.pow(l, -0.6666666666666666)), 3.0))) return t_s * tmp
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (l <= 2.8e+246) tmp = Float64((k ^ -0.5) / Float64((t_m ^ 1.5) * Float64(sqrt(k) / l))) ^ 2.0; else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * (Float64(t_m * (l ^ -0.6666666666666666)) ^ 3.0)))); end return Float64(t_s * tmp) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k) tmp = 0.0; if (l <= 2.8e+246) tmp = ((k ^ -0.5) / ((t_m ^ 1.5) * (sqrt(k) / l))) ^ 2.0; else tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m * (l ^ -0.6666666666666666)) ^ 3.0))); end tmp_2 = t_s * tmp; end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[l, 2.8e+246], N[Power[N[(N[Power[k, -0.5], $MachinePrecision] / N[(N[Power[t$95$m, 1.5], $MachinePrecision] * N[(N[Sqrt[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t$95$m * N[Power[l, -0.6666666666666666], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\ell \leq 2.8 \cdot 10^{+246}:\\
\;\;\;\;{\left(\frac{{k}^{-0.5}}{{t\_m}^{1.5} \cdot \frac{\sqrt{k}}{\ell}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot {\left(t\_m \cdot {\ell}^{-0.6666666666666666}\right)}^{3}\right)}\\
\end{array}
\end{array}
if l < 2.79999999999999988e246Initial program 58.4%
*-commutative58.4%
sqr-neg58.4%
*-commutative58.4%
associate-*l*58.8%
*-commutative58.8%
sqr-neg58.8%
Simplified58.8%
Taylor expanded in k around 0 56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in k around 0 59.2%
associate-/l*58.2%
Simplified58.2%
div-inv58.2%
associate-/r/58.3%
Applied egg-rr58.3%
associate-*r/58.3%
metadata-eval58.3%
*-commutative58.3%
associate-/r*58.3%
*-commutative58.3%
associate-/r*58.3%
metadata-eval58.3%
*-commutative58.3%
Simplified58.3%
add-sqr-sqrt44.1%
sqrt-div16.3%
inv-pow16.3%
sqrt-pow116.3%
metadata-eval16.3%
sqrt-prod16.3%
sqrt-pow116.3%
metadata-eval16.3%
sqrt-div16.3%
unpow216.3%
sqrt-prod8.5%
add-sqr-sqrt13.4%
sqrt-div13.4%
inv-pow13.4%
sqrt-pow113.4%
metadata-eval13.4%
sqrt-prod13.4%
Applied egg-rr19.9%
unpow219.9%
Simplified19.9%
if 2.79999999999999988e246 < l Initial program 39.3%
*-commutative39.3%
sqr-neg39.3%
*-commutative39.3%
associate-*l*39.3%
*-commutative39.3%
sqr-neg39.3%
Simplified39.3%
Taylor expanded in k around 0 55.6%
*-commutative55.6%
Simplified55.6%
rem-cube-cbrt55.6%
cbrt-div55.6%
rem-cbrt-cube67.0%
cbrt-prod82.5%
unpow282.5%
div-inv82.5%
unpow-prod-down55.6%
pow-flip55.6%
metadata-eval55.6%
Applied egg-rr55.6%
cube-prod82.5%
Simplified82.5%
sqr-pow82.5%
metadata-eval82.5%
unpow-182.5%
metadata-eval82.5%
unpow-182.5%
Applied egg-rr82.5%
inv-pow82.5%
inv-pow82.5%
pow-prod-up82.5%
metadata-eval82.5%
pow1/381.8%
pow-pow81.8%
metadata-eval81.8%
Applied egg-rr81.8%
Final simplification24.2%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= l 3e+246)
(/ (/ 1.0 k) (pow (* (pow t_m 1.5) (/ (sqrt k) l)) 2.0))
(/
2.0
(*
(* 2.0 k)
(* (sin k) (pow (* t_m (pow l -0.6666666666666666)) 3.0)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 3e+246) {
tmp = (1.0 / k) / pow((pow(t_m, 1.5) * (sqrt(k) / l)), 2.0);
} else {
tmp = 2.0 / ((2.0 * k) * (sin(k) * pow((t_m * pow(l, -0.6666666666666666)), 3.0)));
}
return t_s * tmp;
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (l <= 3d+246) then
tmp = (1.0d0 / k) / (((t_m ** 1.5d0) * (sqrt(k) / l)) ** 2.0d0)
else
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * ((t_m * (l ** (-0.6666666666666666d0))) ** 3.0d0)))
end if
code = t_s * tmp
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 3e+246) {
tmp = (1.0 / k) / Math.pow((Math.pow(t_m, 1.5) * (Math.sqrt(k) / l)), 2.0);
} else {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * Math.pow((t_m * Math.pow(l, -0.6666666666666666)), 3.0)));
}
return t_s * tmp;
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): tmp = 0 if l <= 3e+246: tmp = (1.0 / k) / math.pow((math.pow(t_m, 1.5) * (math.sqrt(k) / l)), 2.0) else: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * math.pow((t_m * math.pow(l, -0.6666666666666666)), 3.0))) return t_s * tmp
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (l <= 3e+246) tmp = Float64(Float64(1.0 / k) / (Float64((t_m ^ 1.5) * Float64(sqrt(k) / l)) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * (Float64(t_m * (l ^ -0.6666666666666666)) ^ 3.0)))); end return Float64(t_s * tmp) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k) tmp = 0.0; if (l <= 3e+246) tmp = (1.0 / k) / (((t_m ^ 1.5) * (sqrt(k) / l)) ^ 2.0); else tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m * (l ^ -0.6666666666666666)) ^ 3.0))); end tmp_2 = t_s * tmp; end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[l, 3e+246], N[(N[(1.0 / k), $MachinePrecision] / N[Power[N[(N[Power[t$95$m, 1.5], $MachinePrecision] * N[(N[Sqrt[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(t$95$m * N[Power[l, -0.6666666666666666], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\ell \leq 3 \cdot 10^{+246}:\\
\;\;\;\;\frac{\frac{1}{k}}{{\left({t\_m}^{1.5} \cdot \frac{\sqrt{k}}{\ell}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot {\left(t\_m \cdot {\ell}^{-0.6666666666666666}\right)}^{3}\right)}\\
\end{array}
\end{array}
if l < 3e246Initial program 58.4%
*-commutative58.4%
sqr-neg58.4%
*-commutative58.4%
associate-*l*58.8%
*-commutative58.8%
sqr-neg58.8%
Simplified58.8%
Taylor expanded in k around 0 56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in k around 0 59.2%
associate-/l*58.2%
Simplified58.2%
div-inv58.2%
associate-/r/58.3%
Applied egg-rr58.3%
associate-*r/58.3%
metadata-eval58.3%
*-commutative58.3%
associate-/r*58.3%
*-commutative58.3%
associate-/r*58.3%
metadata-eval58.3%
*-commutative58.3%
Simplified58.3%
add-sqr-sqrt32.6%
pow232.6%
sqrt-prod18.0%
sqrt-pow118.4%
metadata-eval18.4%
sqrt-div18.0%
unpow218.0%
sqrt-prod8.9%
add-sqr-sqrt19.9%
Applied egg-rr19.9%
if 3e246 < l Initial program 39.3%
*-commutative39.3%
sqr-neg39.3%
*-commutative39.3%
associate-*l*39.3%
*-commutative39.3%
sqr-neg39.3%
Simplified39.3%
Taylor expanded in k around 0 55.6%
*-commutative55.6%
Simplified55.6%
rem-cube-cbrt55.6%
cbrt-div55.6%
rem-cbrt-cube67.0%
cbrt-prod82.5%
unpow282.5%
div-inv82.5%
unpow-prod-down55.6%
pow-flip55.6%
metadata-eval55.6%
Applied egg-rr55.6%
cube-prod82.5%
Simplified82.5%
sqr-pow82.5%
metadata-eval82.5%
unpow-182.5%
metadata-eval82.5%
unpow-182.5%
Applied egg-rr82.5%
inv-pow82.5%
inv-pow82.5%
pow-prod-up82.5%
metadata-eval82.5%
pow1/381.8%
pow-pow81.8%
metadata-eval81.8%
Applied egg-rr81.8%
Final simplification24.2%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 6e+93)
(/ 2.0 (* (* 2.0 k) (* (sin k) (/ (* t_m (/ (pow t_m 2.0) l)) l))))
(/ (/ 1.0 k) (pow (* t_m (cbrt (* k (pow l -2.0)))) 3.0)))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 6e+93) {
tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m * (pow(t_m, 2.0) / l)) / l)));
} else {
tmp = (1.0 / k) / pow((t_m * cbrt((k * pow(l, -2.0)))), 3.0);
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 6e+93) {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * ((t_m * (Math.pow(t_m, 2.0) / l)) / l)));
} else {
tmp = (1.0 / k) / Math.pow((t_m * Math.cbrt((k * Math.pow(l, -2.0)))), 3.0);
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (k <= 6e+93) tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64(Float64(t_m * Float64((t_m ^ 2.0) / l)) / l)))); else tmp = Float64(Float64(1.0 / k) / (Float64(t_m * cbrt(Float64(k * (l ^ -2.0)))) ^ 3.0)); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[k, 6e+93], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(t$95$m * N[(N[Power[t$95$m, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / k), $MachinePrecision] / N[Power[N[(t$95$m * N[Power[N[(k * N[Power[l, -2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k \leq 6 \cdot 10^{+93}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \frac{t\_m \cdot \frac{{t\_m}^{2}}{\ell}}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{k}}{{\left(t\_m \cdot \sqrt[3]{k \cdot {\ell}^{-2}}\right)}^{3}}\\
\end{array}
\end{array}
if k < 5.99999999999999957e93Initial program 59.4%
associate-*l*59.8%
sqr-neg59.8%
sqr-neg59.8%
associate-/r*64.5%
distribute-rgt-in64.5%
unpow264.5%
times-frac50.7%
sqr-neg50.7%
times-frac64.5%
unpow264.5%
distribute-rgt-in64.5%
Simplified64.5%
cube-mult64.5%
*-un-lft-identity64.5%
times-frac70.6%
pow270.6%
Applied egg-rr70.6%
Taylor expanded in k around 0 67.2%
if 5.99999999999999957e93 < k Initial program 46.5%
*-commutative46.5%
sqr-neg46.5%
*-commutative46.5%
associate-*l*46.5%
*-commutative46.5%
sqr-neg46.5%
Simplified46.5%
Taylor expanded in k around 0 43.5%
*-commutative43.5%
Simplified43.5%
Taylor expanded in k around 0 51.5%
associate-/l*51.4%
Simplified51.4%
div-inv51.4%
associate-/r/51.4%
Applied egg-rr51.4%
associate-*r/51.4%
metadata-eval51.4%
*-commutative51.4%
associate-/r*51.4%
*-commutative51.4%
associate-/r*51.4%
metadata-eval51.4%
*-commutative51.4%
Simplified51.4%
add-cube-cbrt51.4%
pow351.4%
cbrt-prod51.4%
rem-cbrt-cube63.0%
div-inv63.0%
pow-flip63.0%
metadata-eval63.0%
Applied egg-rr63.0%
Final simplification66.4%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 3.2e+25)
(/ (/ 1.0 k) (pow (* (pow t_m 1.5) (/ (sqrt k) l)) 2.0))
(/ (/ 1.0 k) (pow (* t_m (cbrt (* k (pow l -2.0)))) 3.0)))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 3.2e+25) {
tmp = (1.0 / k) / pow((pow(t_m, 1.5) * (sqrt(k) / l)), 2.0);
} else {
tmp = (1.0 / k) / pow((t_m * cbrt((k * pow(l, -2.0)))), 3.0);
}
return t_s * tmp;
}
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 3.2e+25) {
tmp = (1.0 / k) / Math.pow((Math.pow(t_m, 1.5) * (Math.sqrt(k) / l)), 2.0);
} else {
tmp = (1.0 / k) / Math.pow((t_m * Math.cbrt((k * Math.pow(l, -2.0)))), 3.0);
}
return t_s * tmp;
}
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (k <= 3.2e+25) tmp = Float64(Float64(1.0 / k) / (Float64((t_m ^ 1.5) * Float64(sqrt(k) / l)) ^ 2.0)); else tmp = Float64(Float64(1.0 / k) / (Float64(t_m * cbrt(Float64(k * (l ^ -2.0)))) ^ 3.0)); end return Float64(t_s * tmp) end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[k, 3.2e+25], N[(N[(1.0 / k), $MachinePrecision] / N[Power[N[(N[Power[t$95$m, 1.5], $MachinePrecision] * N[(N[Sqrt[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / k), $MachinePrecision] / N[Power[N[(t$95$m * N[Power[N[(k * N[Power[l, -2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k \leq 3.2 \cdot 10^{+25}:\\
\;\;\;\;\frac{\frac{1}{k}}{{\left({t\_m}^{1.5} \cdot \frac{\sqrt{k}}{\ell}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1}{k}}{{\left(t\_m \cdot \sqrt[3]{k \cdot {\ell}^{-2}}\right)}^{3}}\\
\end{array}
\end{array}
if k < 3.1999999999999999e25Initial program 60.2%
*-commutative60.2%
sqr-neg60.2%
*-commutative60.2%
associate-*l*60.7%
*-commutative60.7%
sqr-neg60.7%
Simplified60.7%
Taylor expanded in k around 0 59.3%
*-commutative59.3%
Simplified59.3%
Taylor expanded in k around 0 60.8%
associate-/l*59.7%
Simplified59.7%
div-inv59.7%
associate-/r/59.7%
Applied egg-rr59.7%
associate-*r/59.7%
metadata-eval59.7%
*-commutative59.7%
associate-/r*59.8%
*-commutative59.8%
associate-/r*59.8%
metadata-eval59.8%
*-commutative59.8%
Simplified59.8%
add-sqr-sqrt32.1%
pow232.1%
sqrt-prod14.1%
sqrt-pow115.2%
metadata-eval15.2%
sqrt-div15.2%
unpow215.2%
sqrt-prod8.3%
add-sqr-sqrt17.0%
Applied egg-rr17.0%
if 3.1999999999999999e25 < k Initial program 47.6%
*-commutative47.6%
sqr-neg47.6%
*-commutative47.6%
associate-*l*47.6%
*-commutative47.6%
sqr-neg47.6%
Simplified47.6%
Taylor expanded in k around 0 47.2%
*-commutative47.2%
Simplified47.2%
Taylor expanded in k around 0 50.2%
associate-/l*50.1%
Simplified50.1%
div-inv50.1%
associate-/r/50.0%
Applied egg-rr50.0%
associate-*r/50.0%
metadata-eval50.0%
*-commutative50.0%
associate-/r*50.0%
*-commutative50.0%
associate-/r*50.0%
metadata-eval50.0%
*-commutative50.0%
Simplified50.0%
add-cube-cbrt50.0%
pow350.0%
cbrt-prod50.0%
rem-cbrt-cube58.4%
div-inv58.4%
pow-flip58.4%
metadata-eval58.4%
Applied egg-rr58.4%
Final simplification27.3%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 1.35e+166)
(/ 2.0 (* (* 2.0 k) (* (sin k) (/ (* t_m (/ (pow t_m 2.0) l)) l))))
(/ (pow l 2.0) (* (pow k 2.0) (pow t_m 3.0))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 1.35e+166) {
tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m * (pow(t_m, 2.0) / l)) / l)));
} else {
tmp = pow(l, 2.0) / (pow(k, 2.0) * pow(t_m, 3.0));
}
return t_s * tmp;
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 1.35d+166) then
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * ((t_m * ((t_m ** 2.0d0) / l)) / l)))
else
tmp = (l ** 2.0d0) / ((k ** 2.0d0) * (t_m ** 3.0d0))
end if
code = t_s * tmp
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 1.35e+166) {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * ((t_m * (Math.pow(t_m, 2.0) / l)) / l)));
} else {
tmp = Math.pow(l, 2.0) / (Math.pow(k, 2.0) * Math.pow(t_m, 3.0));
}
return t_s * tmp;
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): tmp = 0 if k <= 1.35e+166: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * ((t_m * (math.pow(t_m, 2.0) / l)) / l))) else: tmp = math.pow(l, 2.0) / (math.pow(k, 2.0) * math.pow(t_m, 3.0)) return t_s * tmp
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (k <= 1.35e+166) tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64(Float64(t_m * Float64((t_m ^ 2.0) / l)) / l)))); else tmp = Float64((l ^ 2.0) / Float64((k ^ 2.0) * (t_m ^ 3.0))); end return Float64(t_s * tmp) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k) tmp = 0.0; if (k <= 1.35e+166) tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m * ((t_m ^ 2.0) / l)) / l))); else tmp = (l ^ 2.0) / ((k ^ 2.0) * (t_m ^ 3.0)); end tmp_2 = t_s * tmp; end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[k, 1.35e+166], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(t$95$m * N[(N[Power[t$95$m, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[l, 2.0], $MachinePrecision] / N[(N[Power[k, 2.0], $MachinePrecision] * N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k \leq 1.35 \cdot 10^{+166}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \frac{t\_m \cdot \frac{{t\_m}^{2}}{\ell}}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{k}^{2} \cdot {t\_m}^{3}}\\
\end{array}
\end{array}
if k < 1.35000000000000006e166Initial program 57.5%
associate-*l*57.9%
sqr-neg57.9%
sqr-neg57.9%
associate-/r*62.6%
distribute-rgt-in62.6%
unpow262.6%
times-frac49.0%
sqr-neg49.0%
times-frac62.6%
unpow262.6%
distribute-rgt-in62.6%
Simplified62.6%
cube-mult62.6%
*-un-lft-identity62.6%
times-frac68.6%
pow268.6%
Applied egg-rr68.6%
Taylor expanded in k around 0 65.6%
if 1.35000000000000006e166 < k Initial program 53.6%
associate-/r*53.6%
sqr-neg53.6%
associate-*l*53.6%
sqr-neg53.6%
associate-/r*60.7%
associate-+l+60.7%
unpow260.7%
times-frac42.9%
sqr-neg42.9%
times-frac60.7%
unpow260.7%
Simplified60.7%
Taylor expanded in k around 0 54.1%
Final simplification64.3%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (or (<= t_m 7.6e-21) (not (<= t_m 4.2e+106)))
(/ 2.0 (* (* 2.0 k) (* (sin k) (/ (* t_m (/ (pow t_m 2.0) l)) l))))
(/ 2.0 (* (* 2.0 k) (/ 1.0 (/ (pow l 2.0) (/ k (pow t_m -3.0)))))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if ((t_m <= 7.6e-21) || !(t_m <= 4.2e+106)) {
tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m * (pow(t_m, 2.0) / l)) / l)));
} else {
tmp = 2.0 / ((2.0 * k) * (1.0 / (pow(l, 2.0) / (k / pow(t_m, -3.0)))));
}
return t_s * tmp;
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((t_m <= 7.6d-21) .or. (.not. (t_m <= 4.2d+106))) then
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * ((t_m * ((t_m ** 2.0d0) / l)) / l)))
else
tmp = 2.0d0 / ((2.0d0 * k) * (1.0d0 / ((l ** 2.0d0) / (k / (t_m ** (-3.0d0))))))
end if
code = t_s * tmp
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if ((t_m <= 7.6e-21) || !(t_m <= 4.2e+106)) {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * ((t_m * (Math.pow(t_m, 2.0) / l)) / l)));
} else {
tmp = 2.0 / ((2.0 * k) * (1.0 / (Math.pow(l, 2.0) / (k / Math.pow(t_m, -3.0)))));
}
return t_s * tmp;
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): tmp = 0 if (t_m <= 7.6e-21) or not (t_m <= 4.2e+106): tmp = 2.0 / ((2.0 * k) * (math.sin(k) * ((t_m * (math.pow(t_m, 2.0) / l)) / l))) else: tmp = 2.0 / ((2.0 * k) * (1.0 / (math.pow(l, 2.0) / (k / math.pow(t_m, -3.0))))) return t_s * tmp
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if ((t_m <= 7.6e-21) || !(t_m <= 4.2e+106)) tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64(Float64(t_m * Float64((t_m ^ 2.0) / l)) / l)))); else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(1.0 / Float64((l ^ 2.0) / Float64(k / (t_m ^ -3.0)))))); end return Float64(t_s * tmp) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k) tmp = 0.0; if ((t_m <= 7.6e-21) || ~((t_m <= 4.2e+106))) tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m * ((t_m ^ 2.0) / l)) / l))); else tmp = 2.0 / ((2.0 * k) * (1.0 / ((l ^ 2.0) / (k / (t_m ^ -3.0))))); end tmp_2 = t_s * tmp; end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[Or[LessEqual[t$95$m, 7.6e-21], N[Not[LessEqual[t$95$m, 4.2e+106]], $MachinePrecision]], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(t$95$m * N[(N[Power[t$95$m, 2.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(1.0 / N[(N[Power[l, 2.0], $MachinePrecision] / N[(k / N[Power[t$95$m, -3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_m \leq 7.6 \cdot 10^{-21} \lor \neg \left(t\_m \leq 4.2 \cdot 10^{+106}\right):\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \frac{t\_m \cdot \frac{{t\_m}^{2}}{\ell}}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \frac{1}{\frac{{\ell}^{2}}{\frac{k}{{t\_m}^{-3}}}}}\\
\end{array}
\end{array}
if t < 7.5999999999999995e-21 or 4.2000000000000001e106 < t Initial program 55.0%
associate-*l*55.4%
sqr-neg55.4%
sqr-neg55.4%
associate-/r*60.5%
distribute-rgt-in60.5%
unpow260.5%
times-frac45.3%
sqr-neg45.3%
times-frac60.5%
unpow260.5%
distribute-rgt-in60.5%
Simplified60.5%
cube-mult60.5%
*-un-lft-identity60.5%
times-frac66.9%
pow266.9%
Applied egg-rr66.9%
Taylor expanded in k around 0 63.9%
if 7.5999999999999995e-21 < t < 4.2000000000000001e106Initial program 76.3%
*-commutative76.3%
sqr-neg76.3%
*-commutative76.3%
associate-*l*76.3%
*-commutative76.3%
sqr-neg76.3%
Simplified76.3%
Taylor expanded in k around 0 65.5%
*-commutative65.5%
Simplified65.5%
Taylor expanded in k around 0 80.2%
associate-/l*68.9%
Simplified68.9%
clear-num68.9%
inv-pow68.9%
div-inv68.9%
pow-flip69.0%
metadata-eval69.0%
Applied egg-rr69.0%
unpow-169.0%
associate-/l*80.2%
Simplified80.2%
Final simplification65.5%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= l 6.5e+245)
(/ (/ 1.0 k) (/ (* k (pow t_m 3.0)) (pow l 2.0)))
(/ 2.0 (* (* 2.0 k) (* (sin k) (/ (pow t_m 3.0) (* l l))))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 6.5e+245) {
tmp = (1.0 / k) / ((k * pow(t_m, 3.0)) / pow(l, 2.0));
} else {
tmp = 2.0 / ((2.0 * k) * (sin(k) * (pow(t_m, 3.0) / (l * l))));
}
return t_s * tmp;
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (l <= 6.5d+245) then
tmp = (1.0d0 / k) / ((k * (t_m ** 3.0d0)) / (l ** 2.0d0))
else
tmp = 2.0d0 / ((2.0d0 * k) * (sin(k) * ((t_m ** 3.0d0) / (l * l))))
end if
code = t_s * tmp
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (l <= 6.5e+245) {
tmp = (1.0 / k) / ((k * Math.pow(t_m, 3.0)) / Math.pow(l, 2.0));
} else {
tmp = 2.0 / ((2.0 * k) * (Math.sin(k) * (Math.pow(t_m, 3.0) / (l * l))));
}
return t_s * tmp;
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): tmp = 0 if l <= 6.5e+245: tmp = (1.0 / k) / ((k * math.pow(t_m, 3.0)) / math.pow(l, 2.0)) else: tmp = 2.0 / ((2.0 * k) * (math.sin(k) * (math.pow(t_m, 3.0) / (l * l)))) return t_s * tmp
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (l <= 6.5e+245) tmp = Float64(Float64(1.0 / k) / Float64(Float64(k * (t_m ^ 3.0)) / (l ^ 2.0))); else tmp = Float64(2.0 / Float64(Float64(2.0 * k) * Float64(sin(k) * Float64((t_m ^ 3.0) / Float64(l * l))))); end return Float64(t_s * tmp) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k) tmp = 0.0; if (l <= 6.5e+245) tmp = (1.0 / k) / ((k * (t_m ^ 3.0)) / (l ^ 2.0)); else tmp = 2.0 / ((2.0 * k) * (sin(k) * ((t_m ^ 3.0) / (l * l)))); end tmp_2 = t_s * tmp; end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[l, 6.5e+245], N[(N[(1.0 / k), $MachinePrecision] / N[(N[(k * N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 * k), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\ell \leq 6.5 \cdot 10^{+245}:\\
\;\;\;\;\frac{\frac{1}{k}}{\frac{k \cdot {t\_m}^{3}}{{\ell}^{2}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot k\right) \cdot \left(\sin k \cdot \frac{{t\_m}^{3}}{\ell \cdot \ell}\right)}\\
\end{array}
\end{array}
if l < 6.50000000000000035e245Initial program 58.6%
*-commutative58.6%
sqr-neg58.6%
*-commutative58.6%
associate-*l*59.0%
*-commutative59.0%
sqr-neg59.0%
Simplified59.0%
Taylor expanded in k around 0 56.6%
*-commutative56.6%
Simplified56.6%
Taylor expanded in k around 0 59.4%
associate-/l*58.5%
Simplified58.5%
div-inv58.5%
associate-/r/58.5%
Applied egg-rr58.5%
associate-*r/58.5%
metadata-eval58.5%
*-commutative58.5%
associate-/r*58.5%
*-commutative58.5%
associate-/r*58.5%
metadata-eval58.5%
*-commutative58.5%
Simplified58.5%
associate-*r/59.4%
Applied egg-rr59.4%
if 6.50000000000000035e245 < l Initial program 37.2%
*-commutative37.2%
sqr-neg37.2%
*-commutative37.2%
associate-*l*37.2%
*-commutative37.2%
sqr-neg37.2%
Simplified37.2%
Taylor expanded in k around 0 52.6%
*-commutative52.6%
Simplified52.6%
Final simplification58.9%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 3.1e+166)
(/ 2.0 (* (/ (* (sin k) (/ (pow t_m 3.0) l)) l) (* 2.0 k)))
(/ 2.0 (/ (* k (* 2.0 k)) (* (pow l 2.0) (pow t_m -3.0)))))))t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 3.1e+166) {
tmp = 2.0 / (((sin(k) * (pow(t_m, 3.0) / l)) / l) * (2.0 * k));
} else {
tmp = 2.0 / ((k * (2.0 * k)) / (pow(l, 2.0) * pow(t_m, -3.0)));
}
return t_s * tmp;
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 3.1d+166) then
tmp = 2.0d0 / (((sin(k) * ((t_m ** 3.0d0) / l)) / l) * (2.0d0 * k))
else
tmp = 2.0d0 / ((k * (2.0d0 * k)) / ((l ** 2.0d0) * (t_m ** (-3.0d0))))
end if
code = t_s * tmp
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
double tmp;
if (k <= 3.1e+166) {
tmp = 2.0 / (((Math.sin(k) * (Math.pow(t_m, 3.0) / l)) / l) * (2.0 * k));
} else {
tmp = 2.0 / ((k * (2.0 * k)) / (Math.pow(l, 2.0) * Math.pow(t_m, -3.0)));
}
return t_s * tmp;
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): tmp = 0 if k <= 3.1e+166: tmp = 2.0 / (((math.sin(k) * (math.pow(t_m, 3.0) / l)) / l) * (2.0 * k)) else: tmp = 2.0 / ((k * (2.0 * k)) / (math.pow(l, 2.0) * math.pow(t_m, -3.0))) return t_s * tmp
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) tmp = 0.0 if (k <= 3.1e+166) tmp = Float64(2.0 / Float64(Float64(Float64(sin(k) * Float64((t_m ^ 3.0) / l)) / l) * Float64(2.0 * k))); else tmp = Float64(2.0 / Float64(Float64(k * Float64(2.0 * k)) / Float64((l ^ 2.0) * (t_m ^ -3.0)))); end return Float64(t_s * tmp) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k) tmp = 0.0; if (k <= 3.1e+166) tmp = 2.0 / (((sin(k) * ((t_m ^ 3.0) / l)) / l) * (2.0 * k)); else tmp = 2.0 / ((k * (2.0 * k)) / ((l ^ 2.0) * (t_m ^ -3.0))); end tmp_2 = t_s * tmp; end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[k, 3.1e+166], N[(2.0 / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision] * N[(2.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(k * N[(2.0 * k), $MachinePrecision]), $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] * N[Power[t$95$m, -3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k \leq 3.1 \cdot 10^{+166}:\\
\;\;\;\;\frac{2}{\frac{\sin k \cdot \frac{{t\_m}^{3}}{\ell}}{\ell} \cdot \left(2 \cdot k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{k \cdot \left(2 \cdot k\right)}{{\ell}^{2} \cdot {t\_m}^{-3}}}\\
\end{array}
\end{array}
if k < 3.09999999999999983e166Initial program 57.5%
associate-*l*57.9%
sqr-neg57.9%
sqr-neg57.9%
associate-/r*62.6%
distribute-rgt-in62.6%
unpow262.6%
times-frac49.0%
sqr-neg49.0%
times-frac62.6%
unpow262.6%
distribute-rgt-in62.6%
Simplified62.6%
associate-*l/63.9%
Applied egg-rr63.9%
Taylor expanded in k around 0 63.0%
if 3.09999999999999983e166 < k Initial program 53.6%
*-commutative53.6%
sqr-neg53.6%
*-commutative53.6%
associate-*l*53.6%
*-commutative53.6%
sqr-neg53.6%
Simplified53.6%
Taylor expanded in k around 0 44.4%
*-commutative44.4%
Simplified44.4%
Taylor expanded in k around 0 54.2%
associate-/l*54.1%
Simplified54.1%
associate-*l/53.6%
div-inv53.6%
pow-flip53.6%
metadata-eval53.6%
Applied egg-rr53.6%
Final simplification62.0%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (/ (/ 1.0 k) (* k (* (pow t_m 3.0) (pow l -2.0))))))
t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / (k * (pow(t_m, 3.0) * pow(l, -2.0))));
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
code = t_s * ((1.0d0 / k) / (k * ((t_m ** 3.0d0) * (l ** (-2.0d0)))))
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / (k * (Math.pow(t_m, 3.0) * Math.pow(l, -2.0))));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * ((1.0 / k) / (k * (math.pow(t_m, 3.0) * math.pow(l, -2.0))))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(Float64(1.0 / k) / Float64(k * Float64((t_m ^ 3.0) * (l ^ -2.0))))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * ((1.0 / k) / (k * ((t_m ^ 3.0) * (l ^ -2.0)))); end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(N[(1.0 / k), $MachinePrecision] / N[(k * N[(N[Power[t$95$m, 3.0], $MachinePrecision] * N[Power[l, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \frac{\frac{1}{k}}{k \cdot \left({t\_m}^{3} \cdot {\ell}^{-2}\right)}
\end{array}
Initial program 57.0%
*-commutative57.0%
sqr-neg57.0%
*-commutative57.0%
associate-*l*57.4%
*-commutative57.4%
sqr-neg57.4%
Simplified57.4%
Taylor expanded in k around 0 56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in k around 0 58.1%
associate-/l*57.3%
Simplified57.3%
div-inv57.3%
associate-/r/57.3%
Applied egg-rr57.3%
associate-*r/57.3%
metadata-eval57.3%
*-commutative57.3%
associate-/r*57.3%
*-commutative57.3%
associate-/r*57.3%
metadata-eval57.3%
*-commutative57.3%
Simplified57.3%
pow157.3%
div-inv56.8%
pow-flip56.8%
metadata-eval56.8%
Applied egg-rr56.8%
unpow156.8%
*-commutative56.8%
associate-*l*56.8%
*-commutative56.8%
Simplified56.8%
Final simplification56.8%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (/ (/ 1.0 k) (* (pow t_m 3.0) (* k (pow l -2.0))))))
t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / (pow(t_m, 3.0) * (k * pow(l, -2.0))));
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
code = t_s * ((1.0d0 / k) / ((t_m ** 3.0d0) * (k * (l ** (-2.0d0)))))
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / (Math.pow(t_m, 3.0) * (k * Math.pow(l, -2.0))));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * ((1.0 / k) / (math.pow(t_m, 3.0) * (k * math.pow(l, -2.0))))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(Float64(1.0 / k) / Float64((t_m ^ 3.0) * Float64(k * (l ^ -2.0))))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * ((1.0 / k) / ((t_m ^ 3.0) * (k * (l ^ -2.0)))); end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(N[(1.0 / k), $MachinePrecision] / N[(N[Power[t$95$m, 3.0], $MachinePrecision] * N[(k * N[Power[l, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \frac{\frac{1}{k}}{{t\_m}^{3} \cdot \left(k \cdot {\ell}^{-2}\right)}
\end{array}
Initial program 57.0%
*-commutative57.0%
sqr-neg57.0%
*-commutative57.0%
associate-*l*57.4%
*-commutative57.4%
sqr-neg57.4%
Simplified57.4%
Taylor expanded in k around 0 56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in k around 0 58.1%
associate-/l*57.3%
Simplified57.3%
div-inv57.3%
associate-/r/57.3%
Applied egg-rr57.3%
associate-*r/57.3%
metadata-eval57.3%
*-commutative57.3%
associate-/r*57.3%
*-commutative57.3%
associate-/r*57.3%
metadata-eval57.3%
*-commutative57.3%
Simplified57.3%
div-inv56.8%
pow-flip56.8%
metadata-eval56.8%
Applied egg-rr56.8%
Final simplification56.8%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (/ (/ 1.0 k) (* (pow t_m 3.0) (/ k (pow l 2.0))))))
t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / (pow(t_m, 3.0) * (k / pow(l, 2.0))));
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
code = t_s * ((1.0d0 / k) / ((t_m ** 3.0d0) * (k / (l ** 2.0d0))))
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / (Math.pow(t_m, 3.0) * (k / Math.pow(l, 2.0))));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * ((1.0 / k) / (math.pow(t_m, 3.0) * (k / math.pow(l, 2.0))))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(Float64(1.0 / k) / Float64((t_m ^ 3.0) * Float64(k / (l ^ 2.0))))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * ((1.0 / k) / ((t_m ^ 3.0) * (k / (l ^ 2.0)))); end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(N[(1.0 / k), $MachinePrecision] / N[(N[Power[t$95$m, 3.0], $MachinePrecision] * N[(k / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \frac{\frac{1}{k}}{{t\_m}^{3} \cdot \frac{k}{{\ell}^{2}}}
\end{array}
Initial program 57.0%
*-commutative57.0%
sqr-neg57.0%
*-commutative57.0%
associate-*l*57.4%
*-commutative57.4%
sqr-neg57.4%
Simplified57.4%
Taylor expanded in k around 0 56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in k around 0 58.1%
associate-/l*57.3%
Simplified57.3%
div-inv57.3%
associate-/r/57.3%
Applied egg-rr57.3%
associate-*r/57.3%
metadata-eval57.3%
*-commutative57.3%
associate-/r*57.3%
*-commutative57.3%
associate-/r*57.3%
metadata-eval57.3%
*-commutative57.3%
Simplified57.3%
Final simplification57.3%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (/ (/ 1.0 k) (/ (* k (pow t_m 3.0)) (pow l 2.0)))))
t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / ((k * pow(t_m, 3.0)) / pow(l, 2.0)));
}
t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k
code = t_s * ((1.0d0 / k) / ((k * (t_m ** 3.0d0)) / (l ** 2.0d0)))
end function
t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
return t_s * ((1.0 / k) / ((k * Math.pow(t_m, 3.0)) / Math.pow(l, 2.0)));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * ((1.0 / k) / ((k * math.pow(t_m, 3.0)) / math.pow(l, 2.0)))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(Float64(1.0 / k) / Float64(Float64(k * (t_m ^ 3.0)) / (l ^ 2.0)))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * ((1.0 / k) / ((k * (t_m ^ 3.0)) / (l ^ 2.0))); end
t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(N[(1.0 / k), $MachinePrecision] / N[(N[(k * N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \frac{\frac{1}{k}}{\frac{k \cdot {t\_m}^{3}}{{\ell}^{2}}}
\end{array}
Initial program 57.0%
*-commutative57.0%
sqr-neg57.0%
*-commutative57.0%
associate-*l*57.4%
*-commutative57.4%
sqr-neg57.4%
Simplified57.4%
Taylor expanded in k around 0 56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in k around 0 58.1%
associate-/l*57.3%
Simplified57.3%
div-inv57.3%
associate-/r/57.3%
Applied egg-rr57.3%
associate-*r/57.3%
metadata-eval57.3%
*-commutative57.3%
associate-/r*57.3%
*-commutative57.3%
associate-/r*57.3%
metadata-eval57.3%
*-commutative57.3%
Simplified57.3%
associate-*r/58.1%
Applied egg-rr58.1%
Final simplification58.1%
herbie shell --seed 2024034
(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))))