
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 20 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (+ (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) + 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) + 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) + 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) + 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) + 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) + 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) + 1\right)}
\end{array}
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 5.1e-11)
(* (/ (cos k) t_m) (pow (/ (* l (sqrt 2.0)) (* k (sin k))) 2.0))
(/
2.0
(*
(+ 2.0 (pow (/ k t_m) 2.0))
(* (tan k) (pow (/ (cbrt (sin k)) (/ (pow (cbrt l) 2.0) 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 <= 5.1e-11) {
tmp = (cos(k) / t_m) * pow(((l * sqrt(2.0)) / (k * sin(k))), 2.0);
} else {
tmp = 2.0 / ((2.0 + pow((k / t_m), 2.0)) * (tan(k) * pow((cbrt(sin(k)) / (pow(cbrt(l), 2.0) / t_m)), 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 <= 5.1e-11) {
tmp = (Math.cos(k) / t_m) * Math.pow(((l * Math.sqrt(2.0)) / (k * Math.sin(k))), 2.0);
} else {
tmp = 2.0 / ((2.0 + Math.pow((k / t_m), 2.0)) * (Math.tan(k) * Math.pow((Math.cbrt(Math.sin(k)) / (Math.pow(Math.cbrt(l), 2.0) / 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 <= 5.1e-11) tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l * sqrt(2.0)) / Float64(k * sin(k))) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(2.0 + (Float64(k / t_m) ^ 2.0)) * Float64(tan(k) * (Float64(cbrt(sin(k)) / Float64((cbrt(l) ^ 2.0) / t_m)) ^ 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, 5.1e-11], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[Power[N[(N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision] / N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $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}\;t_m \leq 5.1 \cdot 10^{-11}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell \cdot \sqrt{2}}{k \cdot \sin k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 + {\left(\frac{k}{t_m}\right)}^{2}\right) \cdot \left(\tan k \cdot {\left(\frac{\sqrt[3]{\sin k}}{\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t_m}}\right)}^{3}\right)}\\
\end{array}
\end{array}
if t < 5.09999999999999984e-11Initial program 52.9%
Simplified50.5%
add-sqr-sqrt35.2%
pow235.2%
Applied egg-rr36.4%
Taylor expanded in k around inf 43.9%
times-frac43.8%
Simplified43.8%
expm1-log1p-u43.1%
expm1-udef37.6%
*-commutative37.6%
unpow-prod-down37.6%
pow237.6%
add-sqr-sqrt51.5%
Applied egg-rr51.5%
expm1-def54.7%
expm1-log1p78.9%
times-frac78.9%
Simplified78.9%
if 5.09999999999999984e-11 < t Initial program 67.2%
associate-/r*74.6%
associate-*l/76.3%
tan-quot76.3%
frac-times76.2%
Applied egg-rr76.2%
distribute-lft-in76.2%
times-frac76.3%
tan-quot76.3%
*-commutative76.3%
times-frac76.3%
tan-quot76.3%
*-commutative76.3%
Applied egg-rr76.3%
distribute-lft-out76.3%
+-commutative76.3%
*-commutative76.3%
associate-+r+76.3%
metadata-eval76.3%
*-commutative76.3%
associate-/l*74.5%
Simplified74.5%
add-cube-cbrt74.3%
pow274.3%
associate-/r/74.4%
cbrt-prod74.3%
cbrt-undiv74.3%
unpow374.3%
add-cbrt-cube74.3%
associate-/r/74.4%
cbrt-prod74.3%
cbrt-undiv74.3%
unpow374.3%
add-cbrt-cube85.9%
Applied egg-rr85.9%
add-cube-cbrt85.7%
Applied egg-rr90.6%
pow-plus90.6%
metadata-eval90.6%
Simplified90.6%
Final simplification81.5%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(let* ((t_2 (+ 1.0 (+ (pow (/ k t_m) 2.0) 1.0))))
(*
t_s
(if (<= (* t_2 (* (tan k) (* (sin k) (/ (pow t_m 3.0) (* l l))))) INFINITY)
(/ 2.0 (* t_2 (* (tan k) (/ (* (sin k) (/ (pow t_m 3.0) l)) l))))
(* (/ (cos k) t_m) (pow (/ (* l (sqrt 2.0)) (* k (sin k))) 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 t_2 = 1.0 + (pow((k / t_m), 2.0) + 1.0);
double tmp;
if ((t_2 * (tan(k) * (sin(k) * (pow(t_m, 3.0) / (l * l))))) <= ((double) INFINITY)) {
tmp = 2.0 / (t_2 * (tan(k) * ((sin(k) * (pow(t_m, 3.0) / l)) / l)));
} else {
tmp = (cos(k) / t_m) * pow(((l * sqrt(2.0)) / (k * sin(k))), 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 t_2 = 1.0 + (Math.pow((k / t_m), 2.0) + 1.0);
double tmp;
if ((t_2 * (Math.tan(k) * (Math.sin(k) * (Math.pow(t_m, 3.0) / (l * l))))) <= Double.POSITIVE_INFINITY) {
tmp = 2.0 / (t_2 * (Math.tan(k) * ((Math.sin(k) * (Math.pow(t_m, 3.0) / l)) / l)));
} else {
tmp = (Math.cos(k) / t_m) * Math.pow(((l * Math.sqrt(2.0)) / (k * Math.sin(k))), 2.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): t_2 = 1.0 + (math.pow((k / t_m), 2.0) + 1.0) tmp = 0 if (t_2 * (math.tan(k) * (math.sin(k) * (math.pow(t_m, 3.0) / (l * l))))) <= math.inf: tmp = 2.0 / (t_2 * (math.tan(k) * ((math.sin(k) * (math.pow(t_m, 3.0) / l)) / l))) else: tmp = (math.cos(k) / t_m) * math.pow(((l * math.sqrt(2.0)) / (k * math.sin(k))), 2.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(1.0 + Float64((Float64(k / t_m) ^ 2.0) + 1.0)) tmp = 0.0 if (Float64(t_2 * Float64(tan(k) * Float64(sin(k) * Float64((t_m ^ 3.0) / Float64(l * l))))) <= Inf) tmp = Float64(2.0 / Float64(t_2 * Float64(tan(k) * Float64(Float64(sin(k) * Float64((t_m ^ 3.0) / l)) / l)))); else tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l * sqrt(2.0)) / Float64(k * sin(k))) ^ 2.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) t_2 = 1.0 + (((k / t_m) ^ 2.0) + 1.0); tmp = 0.0; if ((t_2 * (tan(k) * (sin(k) * ((t_m ^ 3.0) / (l * l))))) <= Inf) tmp = 2.0 / (t_2 * (tan(k) * ((sin(k) * ((t_m ^ 3.0) / l)) / l))); else tmp = (cos(k) / t_m) * (((l * sqrt(2.0)) / (k * sin(k))) ^ 2.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_] := Block[{t$95$2 = N[(1.0 + N[(N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(t$95$2 * 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]), $MachinePrecision], Infinity], N[(2.0 / N[(t$95$2 * N[(N[Tan[k], $MachinePrecision] * N[(N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.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 := 1 + \left({\left(\frac{k}{t_m}\right)}^{2} + 1\right)\\
t_s \cdot \begin{array}{l}
\mathbf{if}\;t_2 \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t_m}^{3}}{\ell \cdot \ell}\right)\right) \leq \infty:\\
\;\;\;\;\frac{2}{t_2 \cdot \left(\tan k \cdot \frac{\sin k \cdot \frac{{t_m}^{3}}{\ell}}{\ell}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell \cdot \sqrt{2}}{k \cdot \sin k}\right)}^{2}\\
\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)) < +inf.0Initial program 83.4%
associate-/r*87.2%
associate-*l/89.4%
Applied egg-rr89.4%
if +inf.0 < (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1)) Initial program 0.0%
Simplified0.0%
add-sqr-sqrt0.0%
pow20.0%
Applied egg-rr18.8%
Taylor expanded in k around inf 53.2%
times-frac53.2%
Simplified53.2%
expm1-log1p-u51.5%
expm1-udef43.7%
*-commutative43.7%
unpow-prod-down43.7%
pow243.7%
add-sqr-sqrt52.5%
Applied egg-rr52.5%
expm1-def59.3%
expm1-log1p80.1%
times-frac80.1%
Simplified80.1%
Final simplification86.4%
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 (<=
(*
(+ 1.0 (+ t_2 1.0))
(* (tan k) (* (sin k) (/ (pow t_m 3.0) (* l l)))))
INFINITY)
(/
2.0
(*
(* (sin k) (/ (* t_m (/ (pow t_m 2.0) l)) l))
(* (+ 2.0 t_2) (tan k))))
(* (/ (cos k) t_m) (pow (/ (* l (sqrt 2.0)) (* k (sin k))) 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 t_2 = pow((k / t_m), 2.0);
double tmp;
if (((1.0 + (t_2 + 1.0)) * (tan(k) * (sin(k) * (pow(t_m, 3.0) / (l * l))))) <= ((double) INFINITY)) {
tmp = 2.0 / ((sin(k) * ((t_m * (pow(t_m, 2.0) / l)) / l)) * ((2.0 + t_2) * tan(k)));
} else {
tmp = (cos(k) / t_m) * pow(((l * sqrt(2.0)) / (k * sin(k))), 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 t_2 = Math.pow((k / t_m), 2.0);
double tmp;
if (((1.0 + (t_2 + 1.0)) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t_m, 3.0) / (l * l))))) <= Double.POSITIVE_INFINITY) {
tmp = 2.0 / ((Math.sin(k) * ((t_m * (Math.pow(t_m, 2.0) / l)) / l)) * ((2.0 + t_2) * Math.tan(k)));
} else {
tmp = (Math.cos(k) / t_m) * Math.pow(((l * Math.sqrt(2.0)) / (k * Math.sin(k))), 2.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): t_2 = math.pow((k / t_m), 2.0) tmp = 0 if ((1.0 + (t_2 + 1.0)) * (math.tan(k) * (math.sin(k) * (math.pow(t_m, 3.0) / (l * l))))) <= math.inf: tmp = 2.0 / ((math.sin(k) * ((t_m * (math.pow(t_m, 2.0) / l)) / l)) * ((2.0 + t_2) * math.tan(k))) else: tmp = (math.cos(k) / t_m) * math.pow(((l * math.sqrt(2.0)) / (k * math.sin(k))), 2.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(k / t_m) ^ 2.0 tmp = 0.0 if (Float64(Float64(1.0 + Float64(t_2 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64((t_m ^ 3.0) / Float64(l * l))))) <= Inf) tmp = Float64(2.0 / Float64(Float64(sin(k) * Float64(Float64(t_m * Float64((t_m ^ 2.0) / l)) / l)) * Float64(Float64(2.0 + t_2) * tan(k)))); else tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l * sqrt(2.0)) / Float64(k * sin(k))) ^ 2.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) t_2 = (k / t_m) ^ 2.0; tmp = 0.0; if (((1.0 + (t_2 + 1.0)) * (tan(k) * (sin(k) * ((t_m ^ 3.0) / (l * l))))) <= Inf) tmp = 2.0 / ((sin(k) * ((t_m * ((t_m ^ 2.0) / l)) / l)) * ((2.0 + t_2) * tan(k))); else tmp = (cos(k) / t_m) * (((l * sqrt(2.0)) / (k * sin(k))) ^ 2.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_] := Block[{t$95$2 = N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(N[(1.0 + N[(t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(2.0 / N[(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] * N[(N[(2.0 + t$95$2), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.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 := {\left(\frac{k}{t_m}\right)}^{2}\\
t_s \cdot \begin{array}{l}
\mathbf{if}\;\left(1 + \left(t_2 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t_m}^{3}}{\ell \cdot \ell}\right)\right) \leq \infty:\\
\;\;\;\;\frac{2}{\left(\sin k \cdot \frac{t_m \cdot \frac{{t_m}^{2}}{\ell}}{\ell}\right) \cdot \left(\left(2 + t_2\right) \cdot \tan k\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell \cdot \sqrt{2}}{k \cdot \sin k}\right)}^{2}\\
\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)) < +inf.0Initial program 83.4%
associate-*l*83.9%
*-commutative83.9%
*-commutative83.9%
associate-/r*87.7%
distribute-rgt-in87.7%
unpow287.7%
times-frac66.3%
sqr-neg66.3%
times-frac87.7%
unpow287.7%
distribute-rgt-in87.7%
+-commutative87.7%
Simplified87.7%
cube-mult87.7%
*-un-lft-identity87.7%
times-frac89.5%
pow289.5%
Applied egg-rr89.5%
if +inf.0 < (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1)) Initial program 0.0%
Simplified0.0%
add-sqr-sqrt0.0%
pow20.0%
Applied egg-rr18.8%
Taylor expanded in k around inf 53.2%
times-frac53.2%
Simplified53.2%
expm1-log1p-u51.5%
expm1-udef43.7%
*-commutative43.7%
unpow-prod-down43.7%
pow243.7%
add-sqr-sqrt52.5%
Applied egg-rr52.5%
expm1-def59.3%
expm1-log1p80.1%
times-frac80.1%
Simplified80.1%
Final simplification86.4%
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 (<=
(*
(+ 1.0 (+ t_2 1.0))
(* (tan k) (* (sin k) (/ (pow t_m 3.0) (* l l)))))
INFINITY)
(/ 2.0 (* (+ 2.0 t_2) (* (tan k) (* (/ (pow t_m 3.0) l) (/ (sin k) l)))))
(* (/ (cos k) t_m) (pow (/ (* l (sqrt 2.0)) (* k (sin k))) 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 t_2 = pow((k / t_m), 2.0);
double tmp;
if (((1.0 + (t_2 + 1.0)) * (tan(k) * (sin(k) * (pow(t_m, 3.0) / (l * l))))) <= ((double) INFINITY)) {
tmp = 2.0 / ((2.0 + t_2) * (tan(k) * ((pow(t_m, 3.0) / l) * (sin(k) / l))));
} else {
tmp = (cos(k) / t_m) * pow(((l * sqrt(2.0)) / (k * sin(k))), 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 t_2 = Math.pow((k / t_m), 2.0);
double tmp;
if (((1.0 + (t_2 + 1.0)) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t_m, 3.0) / (l * l))))) <= Double.POSITIVE_INFINITY) {
tmp = 2.0 / ((2.0 + t_2) * (Math.tan(k) * ((Math.pow(t_m, 3.0) / l) * (Math.sin(k) / l))));
} else {
tmp = (Math.cos(k) / t_m) * Math.pow(((l * Math.sqrt(2.0)) / (k * Math.sin(k))), 2.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): t_2 = math.pow((k / t_m), 2.0) tmp = 0 if ((1.0 + (t_2 + 1.0)) * (math.tan(k) * (math.sin(k) * (math.pow(t_m, 3.0) / (l * l))))) <= math.inf: tmp = 2.0 / ((2.0 + t_2) * (math.tan(k) * ((math.pow(t_m, 3.0) / l) * (math.sin(k) / l)))) else: tmp = (math.cos(k) / t_m) * math.pow(((l * math.sqrt(2.0)) / (k * math.sin(k))), 2.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(k / t_m) ^ 2.0 tmp = 0.0 if (Float64(Float64(1.0 + Float64(t_2 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64((t_m ^ 3.0) / Float64(l * l))))) <= Inf) tmp = Float64(2.0 / Float64(Float64(2.0 + t_2) * Float64(tan(k) * Float64(Float64((t_m ^ 3.0) / l) * Float64(sin(k) / l))))); else tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l * sqrt(2.0)) / Float64(k * sin(k))) ^ 2.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) t_2 = (k / t_m) ^ 2.0; tmp = 0.0; if (((1.0 + (t_2 + 1.0)) * (tan(k) * (sin(k) * ((t_m ^ 3.0) / (l * l))))) <= Inf) tmp = 2.0 / ((2.0 + t_2) * (tan(k) * (((t_m ^ 3.0) / l) * (sin(k) / l)))); else tmp = (cos(k) / t_m) * (((l * sqrt(2.0)) / (k * sin(k))) ^ 2.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_] := Block[{t$95$2 = N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(N[(1.0 + N[(t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(2.0 / N[(N[(2.0 + t$95$2), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[(N[Power[t$95$m, 3.0], $MachinePrecision] / l), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.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 := {\left(\frac{k}{t_m}\right)}^{2}\\
t_s \cdot \begin{array}{l}
\mathbf{if}\;\left(1 + \left(t_2 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t_m}^{3}}{\ell \cdot \ell}\right)\right) \leq \infty:\\
\;\;\;\;\frac{2}{\left(2 + t_2\right) \cdot \left(\tan k \cdot \left(\frac{{t_m}^{3}}{\ell} \cdot \frac{\sin k}{\ell}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell \cdot \sqrt{2}}{k \cdot \sin k}\right)}^{2}\\
\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)) < +inf.0Initial program 83.4%
associate-/r*87.2%
associate-*l/89.4%
tan-quot89.4%
frac-times86.7%
Applied egg-rr86.7%
add-cube-cbrt86.5%
pow386.5%
cbrt-prod86.5%
cbrt-div86.9%
unpow386.9%
add-cbrt-cube90.9%
Applied egg-rr90.9%
distribute-lft-in90.9%
Applied egg-rr89.4%
distribute-lft-out89.4%
associate-*l/89.4%
*-commutative89.4%
+-commutative89.4%
associate-+r+89.4%
metadata-eval89.4%
Simplified89.4%
if +inf.0 < (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1)) Initial program 0.0%
Simplified0.0%
add-sqr-sqrt0.0%
pow20.0%
Applied egg-rr18.8%
Taylor expanded in k around inf 53.2%
times-frac53.2%
Simplified53.2%
expm1-log1p-u51.5%
expm1-udef43.7%
*-commutative43.7%
unpow-prod-down43.7%
pow243.7%
add-sqr-sqrt52.5%
Applied egg-rr52.5%
expm1-def59.3%
expm1-log1p80.1%
times-frac80.1%
Simplified80.1%
Final simplification86.3%
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 7.8e-11)
(* (/ (cos k) t_m) (pow (/ (* l (sqrt 2.0)) (* k (sin k))) 2.0))
(/
2.0
(*
(+ 2.0 (pow (/ k t_m) 2.0))
(* (tan k) (/ (sin k) (pow (* (cbrt l) (/ (cbrt l) 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.8e-11) {
tmp = (cos(k) / t_m) * pow(((l * sqrt(2.0)) / (k * sin(k))), 2.0);
} else {
tmp = 2.0 / ((2.0 + pow((k / t_m), 2.0)) * (tan(k) * (sin(k) / pow((cbrt(l) * (cbrt(l) / t_m)), 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 <= 7.8e-11) {
tmp = (Math.cos(k) / t_m) * Math.pow(((l * Math.sqrt(2.0)) / (k * Math.sin(k))), 2.0);
} else {
tmp = 2.0 / ((2.0 + Math.pow((k / t_m), 2.0)) * (Math.tan(k) * (Math.sin(k) / Math.pow((Math.cbrt(l) * (Math.cbrt(l) / 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.8e-11) tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l * sqrt(2.0)) / Float64(k * sin(k))) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(2.0 + (Float64(k / t_m) ^ 2.0)) * Float64(tan(k) * Float64(sin(k) / (Float64(cbrt(l) * Float64(cbrt(l) / t_m)) ^ 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, 7.8e-11], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] / N[Power[N[(N[Power[l, 1/3], $MachinePrecision] * N[(N[Power[l, 1/3], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], 3.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.8 \cdot 10^{-11}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell \cdot \sqrt{2}}{k \cdot \sin k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 + {\left(\frac{k}{t_m}\right)}^{2}\right) \cdot \left(\tan k \cdot \frac{\sin k}{{\left(\sqrt[3]{\ell} \cdot \frac{\sqrt[3]{\ell}}{t_m}\right)}^{3}}\right)}\\
\end{array}
\end{array}
if t < 7.80000000000000021e-11Initial program 52.9%
Simplified50.5%
add-sqr-sqrt35.2%
pow235.2%
Applied egg-rr36.4%
Taylor expanded in k around inf 43.9%
times-frac43.8%
Simplified43.8%
expm1-log1p-u43.1%
expm1-udef37.6%
*-commutative37.6%
unpow-prod-down37.6%
pow237.6%
add-sqr-sqrt51.5%
Applied egg-rr51.5%
expm1-def54.7%
expm1-log1p78.9%
times-frac78.9%
Simplified78.9%
if 7.80000000000000021e-11 < t Initial program 67.2%
associate-/r*74.6%
associate-*l/76.3%
tan-quot76.3%
frac-times76.2%
Applied egg-rr76.2%
distribute-lft-in76.2%
times-frac76.3%
tan-quot76.3%
*-commutative76.3%
times-frac76.3%
tan-quot76.3%
*-commutative76.3%
Applied egg-rr76.3%
distribute-lft-out76.3%
+-commutative76.3%
*-commutative76.3%
associate-+r+76.3%
metadata-eval76.3%
*-commutative76.3%
associate-/l*74.5%
Simplified74.5%
add-cube-cbrt74.3%
pow374.3%
associate-/r/74.4%
cbrt-prod74.3%
cbrt-undiv74.3%
unpow374.2%
add-cbrt-cube85.8%
Applied egg-rr85.8%
Final simplification80.4%
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.2e-10)
(* (/ (cos k) t_m) (pow (/ (* l (sqrt 2.0)) (* k (sin k))) 2.0))
(/
2.0
(*
(+ 2.0 (pow (/ k t_m) 2.0))
(* (tan k) (/ (sin k) (pow (/ (pow (cbrt l) 2.0) 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 <= 2.2e-10) {
tmp = (cos(k) / t_m) * pow(((l * sqrt(2.0)) / (k * sin(k))), 2.0);
} else {
tmp = 2.0 / ((2.0 + pow((k / t_m), 2.0)) * (tan(k) * (sin(k) / pow((pow(cbrt(l), 2.0) / t_m), 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 <= 2.2e-10) {
tmp = (Math.cos(k) / t_m) * Math.pow(((l * Math.sqrt(2.0)) / (k * Math.sin(k))), 2.0);
} else {
tmp = 2.0 / ((2.0 + Math.pow((k / t_m), 2.0)) * (Math.tan(k) * (Math.sin(k) / Math.pow((Math.pow(Math.cbrt(l), 2.0) / 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 <= 2.2e-10) tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l * sqrt(2.0)) / Float64(k * sin(k))) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(2.0 + (Float64(k / t_m) ^ 2.0)) * Float64(tan(k) * Float64(sin(k) / (Float64((cbrt(l) ^ 2.0) / t_m) ^ 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, 2.2e-10], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] / N[Power[N[(N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / t$95$m), $MachinePrecision], 3.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 2.2 \cdot 10^{-10}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell \cdot \sqrt{2}}{k \cdot \sin k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 + {\left(\frac{k}{t_m}\right)}^{2}\right) \cdot \left(\tan k \cdot \frac{\sin k}{{\left(\frac{{\left(\sqrt[3]{\ell}\right)}^{2}}{t_m}\right)}^{3}}\right)}\\
\end{array}
\end{array}
if t < 2.1999999999999999e-10Initial program 52.9%
Simplified50.5%
add-sqr-sqrt35.2%
pow235.2%
Applied egg-rr36.4%
Taylor expanded in k around inf 43.9%
times-frac43.8%
Simplified43.8%
expm1-log1p-u43.1%
expm1-udef37.6%
*-commutative37.6%
unpow-prod-down37.6%
pow237.6%
add-sqr-sqrt51.5%
Applied egg-rr51.5%
expm1-def54.7%
expm1-log1p78.9%
times-frac78.9%
Simplified78.9%
if 2.1999999999999999e-10 < t Initial program 67.2%
associate-/r*74.6%
associate-*l/76.3%
tan-quot76.3%
frac-times76.2%
Applied egg-rr76.2%
distribute-lft-in76.2%
times-frac76.3%
tan-quot76.3%
*-commutative76.3%
times-frac76.3%
tan-quot76.3%
*-commutative76.3%
Applied egg-rr76.3%
distribute-lft-out76.3%
+-commutative76.3%
*-commutative76.3%
associate-+r+76.3%
metadata-eval76.3%
*-commutative76.3%
associate-/l*74.5%
Simplified74.5%
add-cube-cbrt74.3%
pow274.3%
associate-/r/74.4%
cbrt-prod74.3%
cbrt-undiv74.3%
unpow374.3%
add-cbrt-cube74.3%
associate-/r/74.4%
cbrt-prod74.3%
cbrt-undiv74.3%
unpow374.3%
add-cbrt-cube85.9%
Applied egg-rr85.9%
add-cube-cbrt85.7%
Applied egg-rr90.6%
pow-plus90.6%
metadata-eval90.6%
cube-div85.6%
rem-cube-cbrt85.7%
Simplified85.7%
Final simplification80.4%
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 0.085)
(* (/ (cos k) t_m) (pow (* (/ l k) (/ (sqrt 2.0) (sin k))) 2.0))
(/
2.0
(*
(* (tan k) (* (sin k) (pow (* (pow t_m 1.5) (/ 1.0 l)) 2.0)))
(+ 1.0 (+ (pow (/ k t_m) 2.0) 1.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 <= 0.085) {
tmp = (cos(k) / t_m) * pow(((l / k) * (sqrt(2.0) / sin(k))), 2.0);
} else {
tmp = 2.0 / ((tan(k) * (sin(k) * pow((pow(t_m, 1.5) * (1.0 / l)), 2.0))) * (1.0 + (pow((k / t_m), 2.0) + 1.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 <= 0.085d0) then
tmp = (cos(k) / t_m) * (((l / k) * (sqrt(2.0d0) / sin(k))) ** 2.0d0)
else
tmp = 2.0d0 / ((tan(k) * (sin(k) * (((t_m ** 1.5d0) * (1.0d0 / l)) ** 2.0d0))) * (1.0d0 + (((k / t_m) ** 2.0d0) + 1.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 <= 0.085) {
tmp = (Math.cos(k) / t_m) * Math.pow(((l / k) * (Math.sqrt(2.0) / Math.sin(k))), 2.0);
} else {
tmp = 2.0 / ((Math.tan(k) * (Math.sin(k) * Math.pow((Math.pow(t_m, 1.5) * (1.0 / l)), 2.0))) * (1.0 + (Math.pow((k / t_m), 2.0) + 1.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 <= 0.085: tmp = (math.cos(k) / t_m) * math.pow(((l / k) * (math.sqrt(2.0) / math.sin(k))), 2.0) else: tmp = 2.0 / ((math.tan(k) * (math.sin(k) * math.pow((math.pow(t_m, 1.5) * (1.0 / l)), 2.0))) * (1.0 + (math.pow((k / t_m), 2.0) + 1.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 <= 0.085) tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l / k) * Float64(sqrt(2.0) / sin(k))) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * (Float64((t_m ^ 1.5) * Float64(1.0 / l)) ^ 2.0))) * Float64(1.0 + Float64((Float64(k / t_m) ^ 2.0) + 1.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 <= 0.085) tmp = (cos(k) / t_m) * (((l / k) * (sqrt(2.0) / sin(k))) ^ 2.0); else tmp = 2.0 / ((tan(k) * (sin(k) * (((t_m ^ 1.5) * (1.0 / l)) ^ 2.0))) * (1.0 + (((k / t_m) ^ 2.0) + 1.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[t$95$m, 0.085], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l / k), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(N[Power[t$95$m, 1.5], $MachinePrecision] * N[(1.0 / l), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision] + 1.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}\;t_m \leq 0.085:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell}{k} \cdot \frac{\sqrt{2}}{\sin k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\tan k \cdot \left(\sin k \cdot {\left({t_m}^{1.5} \cdot \frac{1}{\ell}\right)}^{2}\right)\right) \cdot \left(1 + \left({\left(\frac{k}{t_m}\right)}^{2} + 1\right)\right)}\\
\end{array}
\end{array}
if t < 0.0850000000000000061Initial program 52.9%
Simplified50.5%
add-sqr-sqrt35.2%
pow235.2%
Applied egg-rr36.4%
Taylor expanded in k around inf 43.9%
times-frac43.8%
Simplified43.8%
pow-prod-down41.9%
pow241.9%
add-sqr-sqrt78.9%
Applied egg-rr78.9%
if 0.0850000000000000061 < t Initial program 67.2%
add-sqr-sqrt67.1%
pow267.1%
sqrt-div67.0%
sqrt-pow168.8%
metadata-eval68.8%
sqrt-prod37.9%
add-sqr-sqrt81.2%
Applied egg-rr81.2%
div-inv81.2%
Applied egg-rr81.2%
Final simplification79.4%
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 0.09)
(* (/ (cos k) t_m) (pow (* (/ l k) (/ (sqrt 2.0) (sin k))) 2.0))
(/
2.0
(*
(+ 1.0 (+ (pow (/ k t_m) 2.0) 1.0))
(* (tan k) (* (sin k) (pow (/ (pow t_m 1.5) 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) {
double tmp;
if (t_m <= 0.09) {
tmp = (cos(k) / t_m) * pow(((l / k) * (sqrt(2.0) / sin(k))), 2.0);
} else {
tmp = 2.0 / ((1.0 + (pow((k / t_m), 2.0) + 1.0)) * (tan(k) * (sin(k) * pow((pow(t_m, 1.5) / l), 2.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 <= 0.09d0) then
tmp = (cos(k) / t_m) * (((l / k) * (sqrt(2.0d0) / sin(k))) ** 2.0d0)
else
tmp = 2.0d0 / ((1.0d0 + (((k / t_m) ** 2.0d0) + 1.0d0)) * (tan(k) * (sin(k) * (((t_m ** 1.5d0) / l) ** 2.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 <= 0.09) {
tmp = (Math.cos(k) / t_m) * Math.pow(((l / k) * (Math.sqrt(2.0) / Math.sin(k))), 2.0);
} else {
tmp = 2.0 / ((1.0 + (Math.pow((k / t_m), 2.0) + 1.0)) * (Math.tan(k) * (Math.sin(k) * Math.pow((Math.pow(t_m, 1.5) / l), 2.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 <= 0.09: tmp = (math.cos(k) / t_m) * math.pow(((l / k) * (math.sqrt(2.0) / math.sin(k))), 2.0) else: tmp = 2.0 / ((1.0 + (math.pow((k / t_m), 2.0) + 1.0)) * (math.tan(k) * (math.sin(k) * math.pow((math.pow(t_m, 1.5) / l), 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 <= 0.09) tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l / k) * Float64(sqrt(2.0) / sin(k))) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(1.0 + Float64((Float64(k / t_m) ^ 2.0) + 1.0)) * Float64(tan(k) * Float64(sin(k) * (Float64((t_m ^ 1.5) / l) ^ 2.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 <= 0.09) tmp = (cos(k) / t_m) * (((l / k) * (sqrt(2.0) / sin(k))) ^ 2.0); else tmp = 2.0 / ((1.0 + (((k / t_m) ^ 2.0) + 1.0)) * (tan(k) * (sin(k) * (((t_m ^ 1.5) / l) ^ 2.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[t$95$m, 0.09], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l / k), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(1.0 + N[(N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(N[Power[t$95$m, 1.5], $MachinePrecision] / l), $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 0.09:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell}{k} \cdot \frac{\sqrt{2}}{\sin k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(1 + \left({\left(\frac{k}{t_m}\right)}^{2} + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot {\left(\frac{{t_m}^{1.5}}{\ell}\right)}^{2}\right)\right)}\\
\end{array}
\end{array}
if t < 0.089999999999999997Initial program 52.9%
Simplified50.5%
add-sqr-sqrt35.2%
pow235.2%
Applied egg-rr36.4%
Taylor expanded in k around inf 43.9%
times-frac43.8%
Simplified43.8%
pow-prod-down41.9%
pow241.9%
add-sqr-sqrt78.9%
Applied egg-rr78.9%
if 0.089999999999999997 < t Initial program 67.2%
add-sqr-sqrt67.1%
pow267.1%
sqrt-div67.0%
sqrt-pow168.8%
metadata-eval68.8%
sqrt-prod37.9%
add-sqr-sqrt81.2%
Applied egg-rr81.2%
Final simplification79.4%
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 0.0135)
(* (/ (cos k) t_m) (pow (* (/ l k) (/ (sqrt 2.0) (sin k))) 2.0))
(if (<= t_m 7.8e+95)
(*
(* l (/ (/ 2.0 (tan k)) (* (sin k) (pow t_m 3.0))))
(/ l (+ 2.0 (pow (/ k t_m) 2.0))))
(/ (pow l 2.0) (pow (* t_m (pow (cbrt k) 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 (t_m <= 0.0135) {
tmp = (cos(k) / t_m) * pow(((l / k) * (sqrt(2.0) / sin(k))), 2.0);
} else if (t_m <= 7.8e+95) {
tmp = (l * ((2.0 / tan(k)) / (sin(k) * pow(t_m, 3.0)))) * (l / (2.0 + pow((k / t_m), 2.0)));
} else {
tmp = pow(l, 2.0) / pow((t_m * pow(cbrt(k), 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 (t_m <= 0.0135) {
tmp = (Math.cos(k) / t_m) * Math.pow(((l / k) * (Math.sqrt(2.0) / Math.sin(k))), 2.0);
} else if (t_m <= 7.8e+95) {
tmp = (l * ((2.0 / Math.tan(k)) / (Math.sin(k) * Math.pow(t_m, 3.0)))) * (l / (2.0 + Math.pow((k / t_m), 2.0)));
} else {
tmp = Math.pow(l, 2.0) / Math.pow((t_m * Math.pow(Math.cbrt(k), 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 (t_m <= 0.0135) tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l / k) * Float64(sqrt(2.0) / sin(k))) ^ 2.0)); elseif (t_m <= 7.8e+95) tmp = Float64(Float64(l * Float64(Float64(2.0 / tan(k)) / Float64(sin(k) * (t_m ^ 3.0)))) * Float64(l / Float64(2.0 + (Float64(k / t_m) ^ 2.0)))); else tmp = Float64((l ^ 2.0) / (Float64(t_m * (cbrt(k) ^ 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[t$95$m, 0.0135], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l / k), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 7.8e+95], N[(N[(l * N[(N[(2.0 / N[Tan[k], $MachinePrecision]), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l / N[(2.0 + N[Power[N[(k / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[N[(t$95$m * N[Power[N[Power[k, 1/3], $MachinePrecision], 2.0], $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}\;t_m \leq 0.0135:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell}{k} \cdot \frac{\sqrt{2}}{\sin k}\right)}^{2}\\
\mathbf{elif}\;t_m \leq 7.8 \cdot 10^{+95}:\\
\;\;\;\;\left(\ell \cdot \frac{\frac{2}{\tan k}}{\sin k \cdot {t_m}^{3}}\right) \cdot \frac{\ell}{2 + {\left(\frac{k}{t_m}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{\left(t_m \cdot {\left(\sqrt[3]{k}\right)}^{2}\right)}^{3}}\\
\end{array}
\end{array}
if t < 0.0134999999999999998Initial program 52.9%
Simplified50.5%
add-sqr-sqrt35.2%
pow235.2%
Applied egg-rr36.4%
Taylor expanded in k around inf 43.9%
times-frac43.8%
Simplified43.8%
pow-prod-down41.9%
pow241.9%
add-sqr-sqrt78.9%
Applied egg-rr78.9%
if 0.0134999999999999998 < t < 7.7999999999999994e95Initial program 82.2%
Simplified82.2%
associate-*r*87.9%
*-un-lft-identity87.9%
times-frac87.9%
Applied egg-rr87.9%
/-rgt-identity87.9%
*-commutative87.9%
associate-/r*87.9%
*-commutative87.9%
Simplified87.9%
if 7.7999999999999994e95 < t Initial program 61.1%
Simplified61.1%
Taylor expanded in k around 0 50.5%
add-cube-cbrt50.5%
pow350.5%
*-commutative50.5%
cbrt-prod50.5%
unpow350.5%
add-cbrt-cube51.2%
unpow251.2%
cbrt-prod65.9%
pow265.9%
Applied egg-rr65.9%
Final simplification77.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 0.0039)
(pow (* (/ l k) (sqrt (/ 1.0 (pow t_m 3.0)))) 2.0)
(/ 2.0 (/ (* t_m (pow (sin k) 2.0)) (* (cos k) (pow (/ l k) 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 (k <= 0.0039) {
tmp = pow(((l / k) * sqrt((1.0 / pow(t_m, 3.0)))), 2.0);
} else {
tmp = 2.0 / ((t_m * pow(sin(k), 2.0)) / (cos(k) * pow((l / k), 2.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 <= 0.0039d0) then
tmp = ((l / k) * sqrt((1.0d0 / (t_m ** 3.0d0)))) ** 2.0d0
else
tmp = 2.0d0 / ((t_m * (sin(k) ** 2.0d0)) / (cos(k) * ((l / k) ** 2.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 <= 0.0039) {
tmp = Math.pow(((l / k) * Math.sqrt((1.0 / Math.pow(t_m, 3.0)))), 2.0);
} else {
tmp = 2.0 / ((t_m * Math.pow(Math.sin(k), 2.0)) / (Math.cos(k) * Math.pow((l / k), 2.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 <= 0.0039: tmp = math.pow(((l / k) * math.sqrt((1.0 / math.pow(t_m, 3.0)))), 2.0) else: tmp = 2.0 / ((t_m * math.pow(math.sin(k), 2.0)) / (math.cos(k) * math.pow((l / k), 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 (k <= 0.0039) tmp = Float64(Float64(l / k) * sqrt(Float64(1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = Float64(2.0 / Float64(Float64(t_m * (sin(k) ^ 2.0)) / Float64(cos(k) * (Float64(l / k) ^ 2.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 <= 0.0039) tmp = ((l / k) * sqrt((1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = 2.0 / ((t_m * (sin(k) ^ 2.0)) / (cos(k) * ((l / k) ^ 2.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, 0.0039], N[Power[N[(N[(l / k), $MachinePrecision] * N[Sqrt[N[(1.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(2.0 / N[(N[(t$95$m * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[k], $MachinePrecision] * N[Power[N[(l / k), $MachinePrecision], 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 \begin{array}{l}
\mathbf{if}\;k \leq 0.0039:\\
\;\;\;\;{\left(\frac{\ell}{k} \cdot \sqrt{\frac{1}{{t_m}^{3}}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t_m \cdot {\sin k}^{2}}{\cos k \cdot {\left(\frac{\ell}{k}\right)}^{2}}}\\
\end{array}
\end{array}
if k < 0.0038999999999999998Initial program 58.8%
Simplified57.2%
add-sqr-sqrt41.5%
pow241.5%
Applied egg-rr43.2%
Taylor expanded in k around 0 44.7%
if 0.0038999999999999998 < k Initial program 48.3%
associate-/r*51.3%
associate-*l/51.3%
tan-quot51.3%
frac-times51.2%
Applied egg-rr51.2%
distribute-lft-in51.2%
times-frac51.3%
tan-quot51.3%
*-commutative51.3%
times-frac51.3%
tan-quot51.3%
*-commutative51.3%
Applied egg-rr51.3%
distribute-lft-out51.3%
+-commutative51.3%
*-commutative51.3%
associate-+r+51.3%
metadata-eval51.3%
*-commutative51.3%
associate-/l*51.3%
Simplified51.3%
add-cube-cbrt51.1%
pow251.1%
associate-/r/51.2%
cbrt-prod51.1%
cbrt-undiv51.1%
unpow351.1%
add-cbrt-cube51.2%
associate-/r/51.3%
cbrt-prod51.2%
cbrt-undiv51.2%
unpow351.2%
add-cbrt-cube61.4%
Applied egg-rr61.4%
Taylor expanded in k around inf 68.1%
*-commutative68.1%
associate-/l*69.5%
associate-*l/69.5%
unpow269.5%
unpow269.5%
times-frac89.9%
unpow289.9%
Simplified89.9%
Final simplification56.7%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 0.0036)
(pow (* (/ l k) (sqrt (/ 1.0 (pow t_m 3.0)))) 2.0)
(* (/ (cos k) t_m) (pow (/ l (/ (* k (sin k)) (sqrt 2.0))) 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 (k <= 0.0036) {
tmp = pow(((l / k) * sqrt((1.0 / pow(t_m, 3.0)))), 2.0);
} else {
tmp = (cos(k) / t_m) * pow((l / ((k * sin(k)) / sqrt(2.0))), 2.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 <= 0.0036d0) then
tmp = ((l / k) * sqrt((1.0d0 / (t_m ** 3.0d0)))) ** 2.0d0
else
tmp = (cos(k) / t_m) * ((l / ((k * sin(k)) / sqrt(2.0d0))) ** 2.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 <= 0.0036) {
tmp = Math.pow(((l / k) * Math.sqrt((1.0 / Math.pow(t_m, 3.0)))), 2.0);
} else {
tmp = (Math.cos(k) / t_m) * Math.pow((l / ((k * Math.sin(k)) / Math.sqrt(2.0))), 2.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 <= 0.0036: tmp = math.pow(((l / k) * math.sqrt((1.0 / math.pow(t_m, 3.0)))), 2.0) else: tmp = (math.cos(k) / t_m) * math.pow((l / ((k * math.sin(k)) / math.sqrt(2.0))), 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 (k <= 0.0036) tmp = Float64(Float64(l / k) * sqrt(Float64(1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = Float64(Float64(cos(k) / t_m) * (Float64(l / Float64(Float64(k * sin(k)) / sqrt(2.0))) ^ 2.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 <= 0.0036) tmp = ((l / k) * sqrt((1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = (cos(k) / t_m) * ((l / ((k * sin(k)) / sqrt(2.0))) ^ 2.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, 0.0036], N[Power[N[(N[(l / k), $MachinePrecision] * N[Sqrt[N[(1.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(l / N[(N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.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 0.0036:\\
\;\;\;\;{\left(\frac{\ell}{k} \cdot \sqrt{\frac{1}{{t_m}^{3}}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell}{\frac{k \cdot \sin k}{\sqrt{2}}}\right)}^{2}\\
\end{array}
\end{array}
if k < 0.0035999999999999999Initial program 58.8%
Simplified57.2%
add-sqr-sqrt41.5%
pow241.5%
Applied egg-rr43.2%
Taylor expanded in k around 0 44.7%
if 0.0035999999999999999 < k Initial program 48.3%
Simplified45.6%
add-sqr-sqrt41.2%
pow241.2%
Applied egg-rr44.6%
Taylor expanded in k around inf 61.3%
times-frac61.3%
Simplified61.3%
expm1-log1p-u59.7%
expm1-udef52.8%
*-commutative52.8%
unpow-prod-down52.8%
pow252.8%
add-sqr-sqrt72.5%
Applied egg-rr72.5%
expm1-def81.1%
expm1-log1p89.9%
times-frac90.0%
associate-/l*90.0%
Simplified90.0%
Final simplification56.7%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 0.00096)
(pow (* (/ l k) (sqrt (/ 1.0 (pow t_m 3.0)))) 2.0)
(* (/ (cos k) t_m) (pow (/ (* l (sqrt 2.0)) (* k (sin k))) 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 (k <= 0.00096) {
tmp = pow(((l / k) * sqrt((1.0 / pow(t_m, 3.0)))), 2.0);
} else {
tmp = (cos(k) / t_m) * pow(((l * sqrt(2.0)) / (k * sin(k))), 2.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 <= 0.00096d0) then
tmp = ((l / k) * sqrt((1.0d0 / (t_m ** 3.0d0)))) ** 2.0d0
else
tmp = (cos(k) / t_m) * (((l * sqrt(2.0d0)) / (k * sin(k))) ** 2.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 <= 0.00096) {
tmp = Math.pow(((l / k) * Math.sqrt((1.0 / Math.pow(t_m, 3.0)))), 2.0);
} else {
tmp = (Math.cos(k) / t_m) * Math.pow(((l * Math.sqrt(2.0)) / (k * Math.sin(k))), 2.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 <= 0.00096: tmp = math.pow(((l / k) * math.sqrt((1.0 / math.pow(t_m, 3.0)))), 2.0) else: tmp = (math.cos(k) / t_m) * math.pow(((l * math.sqrt(2.0)) / (k * math.sin(k))), 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 (k <= 0.00096) tmp = Float64(Float64(l / k) * sqrt(Float64(1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = Float64(Float64(cos(k) / t_m) * (Float64(Float64(l * sqrt(2.0)) / Float64(k * sin(k))) ^ 2.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 <= 0.00096) tmp = ((l / k) * sqrt((1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = (cos(k) / t_m) * (((l * sqrt(2.0)) / (k * sin(k))) ^ 2.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, 0.00096], N[Power[N[(N[(l / k), $MachinePrecision] * N[Sqrt[N[(1.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.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 0.00096:\\
\;\;\;\;{\left(\frac{\ell}{k} \cdot \sqrt{\frac{1}{{t_m}^{3}}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\cos k}{t_m} \cdot {\left(\frac{\ell \cdot \sqrt{2}}{k \cdot \sin k}\right)}^{2}\\
\end{array}
\end{array}
if k < 9.60000000000000024e-4Initial program 58.8%
Simplified57.2%
add-sqr-sqrt41.5%
pow241.5%
Applied egg-rr43.2%
Taylor expanded in k around 0 44.7%
if 9.60000000000000024e-4 < k Initial program 48.3%
Simplified45.6%
add-sqr-sqrt41.2%
pow241.2%
Applied egg-rr44.6%
Taylor expanded in k around inf 61.3%
times-frac61.3%
Simplified61.3%
expm1-log1p-u59.7%
expm1-udef52.8%
*-commutative52.8%
unpow-prod-down52.8%
pow252.8%
add-sqr-sqrt72.5%
Applied egg-rr72.5%
expm1-def81.1%
expm1-log1p89.9%
times-frac90.0%
Simplified90.0%
Final simplification56.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 2.6e-94)
(pow (* (/ (* l (sqrt 2.0)) (pow k 2.0)) (sqrt (/ 1.0 t_m))) 2.0)
(if (<= t_m 7.8e+95)
(pow (* (/ l k) (sqrt (/ 1.0 (pow t_m 3.0)))) 2.0)
(/ (pow l 2.0) (pow (* t_m (pow (cbrt k) 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 (t_m <= 2.6e-94) {
tmp = pow((((l * sqrt(2.0)) / pow(k, 2.0)) * sqrt((1.0 / t_m))), 2.0);
} else if (t_m <= 7.8e+95) {
tmp = pow(((l / k) * sqrt((1.0 / pow(t_m, 3.0)))), 2.0);
} else {
tmp = pow(l, 2.0) / pow((t_m * pow(cbrt(k), 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 (t_m <= 2.6e-94) {
tmp = Math.pow((((l * Math.sqrt(2.0)) / Math.pow(k, 2.0)) * Math.sqrt((1.0 / t_m))), 2.0);
} else if (t_m <= 7.8e+95) {
tmp = Math.pow(((l / k) * Math.sqrt((1.0 / Math.pow(t_m, 3.0)))), 2.0);
} else {
tmp = Math.pow(l, 2.0) / Math.pow((t_m * Math.pow(Math.cbrt(k), 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 (t_m <= 2.6e-94) tmp = Float64(Float64(Float64(l * sqrt(2.0)) / (k ^ 2.0)) * sqrt(Float64(1.0 / t_m))) ^ 2.0; elseif (t_m <= 7.8e+95) tmp = Float64(Float64(l / k) * sqrt(Float64(1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = Float64((l ^ 2.0) / (Float64(t_m * (cbrt(k) ^ 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[t$95$m, 2.6e-94], N[Power[N[(N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[t$95$m, 7.8e+95], N[Power[N[(N[(l / k), $MachinePrecision] * N[Sqrt[N[(1.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[N[(t$95$m * N[Power[N[Power[k, 1/3], $MachinePrecision], 2.0], $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}\;t_m \leq 2.6 \cdot 10^{-94}:\\
\;\;\;\;{\left(\frac{\ell \cdot \sqrt{2}}{{k}^{2}} \cdot \sqrt{\frac{1}{t_m}}\right)}^{2}\\
\mathbf{elif}\;t_m \leq 7.8 \cdot 10^{+95}:\\
\;\;\;\;{\left(\frac{\ell}{k} \cdot \sqrt{\frac{1}{{t_m}^{3}}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2}}{{\left(t_m \cdot {\left(\sqrt[3]{k}\right)}^{2}\right)}^{3}}\\
\end{array}
\end{array}
if t < 2.59999999999999994e-94Initial program 51.8%
Simplified49.1%
add-sqr-sqrt32.3%
pow232.3%
Applied egg-rr34.1%
Taylor expanded in k around inf 42.3%
times-frac42.3%
Simplified42.3%
Taylor expanded in k around 0 16.7%
if 2.59999999999999994e-94 < t < 7.7999999999999994e95Initial program 72.1%
Simplified71.9%
add-sqr-sqrt66.1%
pow266.1%
Applied egg-rr63.3%
Taylor expanded in k around 0 71.9%
if 7.7999999999999994e95 < t Initial program 61.1%
Simplified61.1%
Taylor expanded in k around 0 50.5%
add-cube-cbrt50.5%
pow350.5%
*-commutative50.5%
cbrt-prod50.5%
unpow350.5%
add-cbrt-cube51.2%
unpow251.2%
cbrt-prod65.9%
pow265.9%
Applied egg-rr65.9%
Final simplification31.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 2.4e+15)
(pow (* (/ l k) (sqrt (/ 1.0 (pow t_m 3.0)))) 2.0)
(pow (/ (cbrt (* (pow l 2.0) (pow k -2.0))) 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 <= 2.4e+15) {
tmp = pow(((l / k) * sqrt((1.0 / pow(t_m, 3.0)))), 2.0);
} else {
tmp = pow((cbrt((pow(l, 2.0) * pow(k, -2.0))) / t_m), 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.4e+15) {
tmp = Math.pow(((l / k) * Math.sqrt((1.0 / Math.pow(t_m, 3.0)))), 2.0);
} else {
tmp = Math.pow((Math.cbrt((Math.pow(l, 2.0) * Math.pow(k, -2.0))) / 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 <= 2.4e+15) tmp = Float64(Float64(l / k) * sqrt(Float64(1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = Float64(cbrt(Float64((l ^ 2.0) * (k ^ -2.0))) / t_m) ^ 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.4e+15], N[Power[N[(N[(l / k), $MachinePrecision] * N[Sqrt[N[(1.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[Power[N[(N[Power[N[(N[Power[l, 2.0], $MachinePrecision] * N[Power[k, -2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t$95$m), $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.4 \cdot 10^{+15}:\\
\;\;\;\;{\left(\frac{\ell}{k} \cdot \sqrt{\frac{1}{{t_m}^{3}}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{{\ell}^{2} \cdot {k}^{-2}}}{t_m}\right)}^{3}\\
\end{array}
\end{array}
if k < 2.4e15Initial program 58.6%
Simplified57.0%
add-sqr-sqrt41.7%
pow241.7%
Applied egg-rr43.9%
Taylor expanded in k around 0 44.9%
if 2.4e15 < k Initial program 48.3%
Simplified45.4%
Taylor expanded in t around inf 38.0%
associate-/l*38.0%
*-commutative38.0%
associate-/l*36.4%
Simplified36.4%
Taylor expanded in k around 0 37.1%
associate-/r*38.5%
Simplified38.5%
add-cube-cbrt38.5%
pow338.5%
cbrt-div38.5%
div-inv38.5%
pow-flip38.5%
metadata-eval38.5%
unpow338.5%
add-cbrt-cube54.3%
Applied egg-rr54.3%
Final simplification47.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 3.7e+14)
(pow (* (/ l k) (sqrt (/ 1.0 (pow t_m 3.0)))) 2.0)
(pow (/ (cbrt (/ (pow l 2.0) (pow k 2.0))) 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.7e+14) {
tmp = pow(((l / k) * sqrt((1.0 / pow(t_m, 3.0)))), 2.0);
} else {
tmp = pow((cbrt((pow(l, 2.0) / pow(k, 2.0))) / t_m), 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.7e+14) {
tmp = Math.pow(((l / k) * Math.sqrt((1.0 / Math.pow(t_m, 3.0)))), 2.0);
} else {
tmp = Math.pow((Math.cbrt((Math.pow(l, 2.0) / Math.pow(k, 2.0))) / 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.7e+14) tmp = Float64(Float64(l / k) * sqrt(Float64(1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = Float64(cbrt(Float64((l ^ 2.0) / (k ^ 2.0))) / t_m) ^ 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.7e+14], N[Power[N[(N[(l / k), $MachinePrecision] * N[Sqrt[N[(1.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[Power[N[(N[Power[N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t$95$m), $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 3.7 \cdot 10^{+14}:\\
\;\;\;\;{\left(\frac{\ell}{k} \cdot \sqrt{\frac{1}{{t_m}^{3}}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{\sqrt[3]{\frac{{\ell}^{2}}{{k}^{2}}}}{t_m}\right)}^{3}\\
\end{array}
\end{array}
if k < 3.7e14Initial program 58.6%
Simplified57.0%
add-sqr-sqrt41.7%
pow241.7%
Applied egg-rr43.9%
Taylor expanded in k around 0 44.9%
if 3.7e14 < k Initial program 48.3%
Simplified45.4%
Taylor expanded in k around 0 37.1%
add-cube-cbrt37.1%
pow337.1%
associate-/r*38.5%
cbrt-div38.5%
unpow338.5%
add-cbrt-cube54.3%
Applied egg-rr54.3%
Final simplification47.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 3.7e+177)
(* (pow (/ l k) 2.0) (* (cos k) (pow t_m -3.0)))
(/ (/ (/ 2.0 t_m) (pow k 4.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) {
double tmp;
if (k <= 3.7e+177) {
tmp = pow((l / k), 2.0) * (cos(k) * pow(t_m, -3.0));
} else {
tmp = ((2.0 / t_m) / pow(k, 4.0)) / pow(l, -2.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.7d+177) then
tmp = ((l / k) ** 2.0d0) * (cos(k) * (t_m ** (-3.0d0)))
else
tmp = ((2.0d0 / t_m) / (k ** 4.0d0)) / (l ** (-2.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.7e+177) {
tmp = Math.pow((l / k), 2.0) * (Math.cos(k) * Math.pow(t_m, -3.0));
} else {
tmp = ((2.0 / t_m) / Math.pow(k, 4.0)) / Math.pow(l, -2.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.7e+177: tmp = math.pow((l / k), 2.0) * (math.cos(k) * math.pow(t_m, -3.0)) else: tmp = ((2.0 / t_m) / math.pow(k, 4.0)) / math.pow(l, -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 (k <= 3.7e+177) tmp = Float64((Float64(l / k) ^ 2.0) * Float64(cos(k) * (t_m ^ -3.0))); else tmp = Float64(Float64(Float64(2.0 / t_m) / (k ^ 4.0)) / (l ^ -2.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.7e+177) tmp = ((l / k) ^ 2.0) * (cos(k) * (t_m ^ -3.0)); else tmp = ((2.0 / t_m) / (k ^ 4.0)) / (l ^ -2.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.7e+177], N[(N[Power[N[(l / k), $MachinePrecision], 2.0], $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] * N[Power[t$95$m, -3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 / t$95$m), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, -2.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.7 \cdot 10^{+177}:\\
\;\;\;\;{\left(\frac{\ell}{k}\right)}^{2} \cdot \left(\cos k \cdot {t_m}^{-3}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{2}{t_m}}{{k}^{4}}}{{\ell}^{-2}}\\
\end{array}
\end{array}
if k < 3.70000000000000014e177Initial program 59.1%
Simplified56.9%
Taylor expanded in t around inf 49.8%
associate-/l*49.8%
*-commutative49.8%
associate-/l*49.3%
Simplified49.3%
Taylor expanded in k around 0 51.3%
expm1-log1p-u37.6%
expm1-udef37.7%
associate-/r/37.7%
div-inv37.7%
pow-flip37.7%
metadata-eval37.7%
Applied egg-rr37.7%
expm1-def38.1%
expm1-log1p52.6%
*-commutative52.6%
unpow252.6%
unpow252.6%
times-frac63.5%
unpow263.5%
Simplified63.5%
if 3.70000000000000014e177 < k Initial program 33.3%
add-sqr-sqrt10.0%
pow210.0%
sqrt-div10.0%
sqrt-pow113.5%
metadata-eval13.5%
sqrt-prod9.9%
add-sqr-sqrt19.9%
Applied egg-rr19.9%
Taylor expanded in t around 0 60.3%
associate-*r*60.3%
times-frac60.3%
Simplified60.3%
Taylor expanded in k around 0 60.3%
div-inv60.3%
div-inv60.3%
*-commutative60.3%
pow-flip60.3%
metadata-eval60.3%
Applied egg-rr60.3%
associate-*r/60.3%
metadata-eval60.3%
associate-/r*60.3%
associate-/r*60.3%
Simplified60.3%
Final simplification63.1%
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.3e+131)
(pow (* (/ l k) (sqrt (/ 1.0 (pow t_m 3.0)))) 2.0)
(/ (/ (/ 2.0 t_m) (pow k 4.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) {
double tmp;
if (k <= 2.3e+131) {
tmp = pow(((l / k) * sqrt((1.0 / pow(t_m, 3.0)))), 2.0);
} else {
tmp = ((2.0 / t_m) / pow(k, 4.0)) / pow(l, -2.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 <= 2.3d+131) then
tmp = ((l / k) * sqrt((1.0d0 / (t_m ** 3.0d0)))) ** 2.0d0
else
tmp = ((2.0d0 / t_m) / (k ** 4.0d0)) / (l ** (-2.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 <= 2.3e+131) {
tmp = Math.pow(((l / k) * Math.sqrt((1.0 / Math.pow(t_m, 3.0)))), 2.0);
} else {
tmp = ((2.0 / t_m) / Math.pow(k, 4.0)) / Math.pow(l, -2.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 <= 2.3e+131: tmp = math.pow(((l / k) * math.sqrt((1.0 / math.pow(t_m, 3.0)))), 2.0) else: tmp = ((2.0 / t_m) / math.pow(k, 4.0)) / math.pow(l, -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 (k <= 2.3e+131) tmp = Float64(Float64(l / k) * sqrt(Float64(1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = Float64(Float64(Float64(2.0 / t_m) / (k ^ 4.0)) / (l ^ -2.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 <= 2.3e+131) tmp = ((l / k) * sqrt((1.0 / (t_m ^ 3.0)))) ^ 2.0; else tmp = ((2.0 / t_m) / (k ^ 4.0)) / (l ^ -2.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, 2.3e+131], N[Power[N[(N[(l / k), $MachinePrecision] * N[Sqrt[N[(1.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(2.0 / t$95$m), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] / N[Power[l, -2.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 2.3 \cdot 10^{+131}:\\
\;\;\;\;{\left(\frac{\ell}{k} \cdot \sqrt{\frac{1}{{t_m}^{3}}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{2}{t_m}}{{k}^{4}}}{{\ell}^{-2}}\\
\end{array}
\end{array}
if k < 2.29999999999999992e131Initial program 60.0%
Simplified57.7%
add-sqr-sqrt42.5%
pow242.5%
Applied egg-rr44.6%
Taylor expanded in k around 0 44.1%
if 2.29999999999999992e131 < k Initial program 35.7%
add-sqr-sqrt11.9%
pow211.9%
sqrt-div11.9%
sqrt-pow116.8%
metadata-eval16.8%
sqrt-prod11.8%
add-sqr-sqrt21.4%
Applied egg-rr21.4%
Taylor expanded in t around 0 62.3%
associate-*r*62.3%
times-frac62.3%
Simplified62.3%
Taylor expanded in k around 0 52.9%
div-inv52.9%
div-inv52.9%
*-commutative52.9%
pow-flip52.9%
metadata-eval52.9%
Applied egg-rr52.9%
associate-*r/52.9%
metadata-eval52.9%
associate-/r*52.9%
associate-/r*52.9%
Simplified52.9%
Final simplification45.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 4.3e-125)
(* 2.0 (/ (/ (pow l 2.0) (pow k 4.0)) t_m))
(/ (pow (/ l 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 (t_m <= 4.3e-125) {
tmp = 2.0 * ((pow(l, 2.0) / pow(k, 4.0)) / t_m);
} else {
tmp = pow((l / 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 (t_m <= 4.3d-125) then
tmp = 2.0d0 * (((l ** 2.0d0) / (k ** 4.0d0)) / t_m)
else
tmp = ((l / 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 (t_m <= 4.3e-125) {
tmp = 2.0 * ((Math.pow(l, 2.0) / Math.pow(k, 4.0)) / t_m);
} else {
tmp = Math.pow((l / 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 t_m <= 4.3e-125: tmp = 2.0 * ((math.pow(l, 2.0) / math.pow(k, 4.0)) / t_m) else: tmp = math.pow((l / 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 (t_m <= 4.3e-125) tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) / (k ^ 4.0)) / t_m)); else tmp = Float64((Float64(l / 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 (t_m <= 4.3e-125) tmp = 2.0 * (((l ^ 2.0) / (k ^ 4.0)) / t_m); else tmp = ((l / 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[t$95$m, 4.3e-125], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(l / k), $MachinePrecision], 2.0], $MachinePrecision] / N[Power[t$95$m, 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}\;t_m \leq 4.3 \cdot 10^{-125}:\\
\;\;\;\;2 \cdot \frac{\frac{{\ell}^{2}}{{k}^{4}}}{t_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{\ell}{k}\right)}^{2}}{{t_m}^{3}}\\
\end{array}
\end{array}
if t < 4.3000000000000002e-125Initial program 51.1%
add-sqr-sqrt6.3%
pow26.3%
sqrt-div6.3%
sqrt-pow17.9%
metadata-eval7.9%
sqrt-prod4.5%
add-sqr-sqrt9.1%
Applied egg-rr9.1%
Taylor expanded in t around 0 62.5%
associate-*r*62.5%
times-frac64.3%
Simplified64.3%
Taylor expanded in k around 0 51.7%
Taylor expanded in k around 0 51.7%
associate-/r*52.3%
Simplified52.3%
if 4.3000000000000002e-125 < t Initial program 66.5%
Simplified65.4%
Taylor expanded in t around inf 47.8%
associate-/l*47.8%
*-commutative47.8%
associate-/l*47.8%
Simplified47.8%
Taylor expanded in k around 0 53.3%
Taylor expanded in k around 0 53.3%
associate-/r*53.3%
unpow253.3%
unpow253.3%
times-frac66.9%
unpow266.9%
Simplified66.9%
Final simplification57.0%
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.2e-124)
(/ 2.0 (/ (pow k 4.0) (/ (pow l 2.0) t_m)))
(/ (pow (/ l 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 (t_m <= 3.2e-124) {
tmp = 2.0 / (pow(k, 4.0) / (pow(l, 2.0) / t_m));
} else {
tmp = pow((l / 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 (t_m <= 3.2d-124) then
tmp = 2.0d0 / ((k ** 4.0d0) / ((l ** 2.0d0) / t_m))
else
tmp = ((l / 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 (t_m <= 3.2e-124) {
tmp = 2.0 / (Math.pow(k, 4.0) / (Math.pow(l, 2.0) / t_m));
} else {
tmp = Math.pow((l / 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 t_m <= 3.2e-124: tmp = 2.0 / (math.pow(k, 4.0) / (math.pow(l, 2.0) / t_m)) else: tmp = math.pow((l / 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 (t_m <= 3.2e-124) tmp = Float64(2.0 / Float64((k ^ 4.0) / Float64((l ^ 2.0) / t_m))); else tmp = Float64((Float64(l / 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 (t_m <= 3.2e-124) tmp = 2.0 / ((k ^ 4.0) / ((l ^ 2.0) / t_m)); else tmp = ((l / 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[t$95$m, 3.2e-124], N[(2.0 / N[(N[Power[k, 4.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(l / k), $MachinePrecision], 2.0], $MachinePrecision] / N[Power[t$95$m, 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}\;t_m \leq 3.2 \cdot 10^{-124}:\\
\;\;\;\;\frac{2}{\frac{{k}^{4}}{\frac{{\ell}^{2}}{t_m}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(\frac{\ell}{k}\right)}^{2}}{{t_m}^{3}}\\
\end{array}
\end{array}
if t < 3.20000000000000004e-124Initial program 51.1%
add-sqr-sqrt6.3%
pow26.3%
sqrt-div6.3%
sqrt-pow17.9%
metadata-eval7.9%
sqrt-prod4.5%
add-sqr-sqrt9.1%
Applied egg-rr9.1%
Taylor expanded in t around 0 62.5%
associate-*r*62.5%
times-frac64.3%
Simplified64.3%
Taylor expanded in k around 0 51.7%
associate-/l*53.8%
Simplified53.8%
if 3.20000000000000004e-124 < t Initial program 66.5%
Simplified65.4%
Taylor expanded in t around inf 47.8%
associate-/l*47.8%
*-commutative47.8%
associate-/l*47.8%
Simplified47.8%
Taylor expanded in k around 0 53.3%
Taylor expanded in k around 0 53.3%
associate-/r*53.3%
unpow253.3%
unpow253.3%
times-frac66.9%
unpow266.9%
Simplified66.9%
Final simplification58.0%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (/ (pow (/ l 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) {
return t_s * (pow((l / k), 2.0) / pow(t_m, 3.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 * (((l / k) ** 2.0d0) / (t_m ** 3.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 * (Math.pow((l / k), 2.0) / Math.pow(t_m, 3.0));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * (math.pow((l / k), 2.0) / math.pow(t_m, 3.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(l / k) ^ 2.0) / (t_m ^ 3.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 * (((l / k) ^ 2.0) / (t_m ^ 3.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[Power[N[(l / k), $MachinePrecision], 2.0], $MachinePrecision] / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t_s \cdot \frac{{\left(\frac{\ell}{k}\right)}^{2}}{{t_m}^{3}}
\end{array}
Initial program 56.0%
Simplified54.1%
Taylor expanded in t around inf 47.6%
associate-/l*47.6%
*-commutative47.6%
associate-/l*47.3%
Simplified47.3%
Taylor expanded in k around 0 49.2%
Taylor expanded in k around 0 48.7%
associate-/r*49.5%
unpow249.5%
unpow249.5%
times-frac59.0%
unpow259.0%
Simplified59.0%
Final simplification59.0%
herbie shell --seed 2023331
(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))))