
(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 13 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 (/ 2.0 (/ (pow (* (/ k l) (* (sin k) (sqrt t_m))) 2.0) (cos k)))))
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 * (2.0 / (pow(((k / l) * (sin(k) * sqrt(t_m))), 2.0) / cos(k)));
}
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 * (2.0d0 / ((((k / l) * (sin(k) * sqrt(t_m))) ** 2.0d0) / cos(k)))
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 * (2.0 / (Math.pow(((k / l) * (Math.sin(k) * Math.sqrt(t_m))), 2.0) / Math.cos(k)));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * (2.0 / (math.pow(((k / l) * (math.sin(k) * math.sqrt(t_m))), 2.0) / math.cos(k)))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(2.0 / Float64((Float64(Float64(k / l) * Float64(sin(k) * sqrt(t_m))) ^ 2.0) / cos(k)))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * (2.0 / ((((k / l) * (sin(k) * sqrt(t_m))) ^ 2.0) / cos(k))); 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[(2.0 / N[(N[Power[N[(N[(k / l), $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t_s \cdot \frac{2}{\frac{{\left(\frac{k}{\ell} \cdot \left(\sin k \cdot \sqrt{t_m}\right)\right)}^{2}}{\cos k}}
\end{array}
Initial program 36.8%
Taylor expanded in t around 0 74.9%
times-frac77.5%
Simplified77.5%
add-sqr-sqrt77.5%
sqrt-div77.5%
unpow277.5%
sqrt-prod41.1%
add-sqr-sqrt56.4%
pow256.4%
sqrt-prod28.7%
add-sqr-sqrt51.4%
sqrt-div51.4%
unpow251.4%
sqrt-prod24.8%
add-sqr-sqrt50.3%
pow250.3%
sqrt-prod43.5%
add-sqr-sqrt92.8%
Applied egg-rr92.8%
expm1-log1p-u74.2%
expm1-udef34.5%
Applied egg-rr26.4%
expm1-def34.5%
expm1-log1p40.8%
Simplified40.8%
Final simplification40.8%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (/ 2.0 (/ (pow (* (sqrt t_m) (* (/ k l) (sin k))) 2.0) (cos k)))))
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 * (2.0 / (pow((sqrt(t_m) * ((k / l) * sin(k))), 2.0) / cos(k)));
}
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 * (2.0d0 / (((sqrt(t_m) * ((k / l) * sin(k))) ** 2.0d0) / cos(k)))
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 * (2.0 / (Math.pow((Math.sqrt(t_m) * ((k / l) * Math.sin(k))), 2.0) / Math.cos(k)));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * (2.0 / (math.pow((math.sqrt(t_m) * ((k / l) * math.sin(k))), 2.0) / math.cos(k)))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(2.0 / Float64((Float64(sqrt(t_m) * Float64(Float64(k / l) * sin(k))) ^ 2.0) / cos(k)))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * (2.0 / (((sqrt(t_m) * ((k / l) * sin(k))) ^ 2.0) / cos(k))); 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[(2.0 / N[(N[Power[N[(N[Sqrt[t$95$m], $MachinePrecision] * N[(N[(k / l), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t_s \cdot \frac{2}{\frac{{\left(\sqrt{t_m} \cdot \left(\frac{k}{\ell} \cdot \sin k\right)\right)}^{2}}{\cos k}}
\end{array}
Initial program 36.8%
Taylor expanded in t around 0 74.9%
times-frac77.5%
Simplified77.5%
add-sqr-sqrt77.5%
sqrt-div77.5%
unpow277.5%
sqrt-prod41.1%
add-sqr-sqrt56.4%
pow256.4%
sqrt-prod28.7%
add-sqr-sqrt51.4%
sqrt-div51.4%
unpow251.4%
sqrt-prod24.8%
add-sqr-sqrt50.3%
pow250.3%
sqrt-prod43.5%
add-sqr-sqrt92.8%
Applied egg-rr92.8%
expm1-log1p-u74.2%
expm1-udef34.5%
Applied egg-rr26.4%
expm1-def34.5%
expm1-log1p40.8%
Simplified40.8%
Taylor expanded in k around inf 40.0%
associate-*l/40.8%
*-commutative40.8%
*-commutative40.8%
Simplified40.8%
Final simplification40.8%
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.2e-62)
(/ 2.0 (/ (pow (* (/ k l) (* k (sqrt t_m))) 2.0) (cos k)))
(if (<= k 1.1e+95)
(/ 2.0 (/ (* (* k (/ k l)) (* t_m (pow (sin k) 2.0))) (* l (cos k))))
(* (cos k) (/ 2.0 (* t_m (pow (* (/ k l) (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 <= 1.2e-62) {
tmp = 2.0 / (pow(((k / l) * (k * sqrt(t_m))), 2.0) / cos(k));
} else if (k <= 1.1e+95) {
tmp = 2.0 / (((k * (k / l)) * (t_m * pow(sin(k), 2.0))) / (l * cos(k)));
} else {
tmp = cos(k) * (2.0 / (t_m * pow(((k / l) * 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 <= 1.2d-62) then
tmp = 2.0d0 / ((((k / l) * (k * sqrt(t_m))) ** 2.0d0) / cos(k))
else if (k <= 1.1d+95) then
tmp = 2.0d0 / (((k * (k / l)) * (t_m * (sin(k) ** 2.0d0))) / (l * cos(k)))
else
tmp = cos(k) * (2.0d0 / (t_m * (((k / l) * 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 <= 1.2e-62) {
tmp = 2.0 / (Math.pow(((k / l) * (k * Math.sqrt(t_m))), 2.0) / Math.cos(k));
} else if (k <= 1.1e+95) {
tmp = 2.0 / (((k * (k / l)) * (t_m * Math.pow(Math.sin(k), 2.0))) / (l * Math.cos(k)));
} else {
tmp = Math.cos(k) * (2.0 / (t_m * Math.pow(((k / l) * 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 <= 1.2e-62: tmp = 2.0 / (math.pow(((k / l) * (k * math.sqrt(t_m))), 2.0) / math.cos(k)) elif k <= 1.1e+95: tmp = 2.0 / (((k * (k / l)) * (t_m * math.pow(math.sin(k), 2.0))) / (l * math.cos(k))) else: tmp = math.cos(k) * (2.0 / (t_m * math.pow(((k / l) * 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 <= 1.2e-62) tmp = Float64(2.0 / Float64((Float64(Float64(k / l) * Float64(k * sqrt(t_m))) ^ 2.0) / cos(k))); elseif (k <= 1.1e+95) tmp = Float64(2.0 / Float64(Float64(Float64(k * Float64(k / l)) * Float64(t_m * (sin(k) ^ 2.0))) / Float64(l * cos(k)))); else tmp = Float64(cos(k) * Float64(2.0 / Float64(t_m * (Float64(Float64(k / l) * 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 <= 1.2e-62) tmp = 2.0 / ((((k / l) * (k * sqrt(t_m))) ^ 2.0) / cos(k)); elseif (k <= 1.1e+95) tmp = 2.0 / (((k * (k / l)) * (t_m * (sin(k) ^ 2.0))) / (l * cos(k))); else tmp = cos(k) * (2.0 / (t_m * (((k / l) * 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, 1.2e-62], N[(2.0 / N[(N[Power[N[(N[(k / l), $MachinePrecision] * N[(k * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 1.1e+95], N[(2.0 / N[(N[(N[(k * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(t$95$m * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(l * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Cos[k], $MachinePrecision] * N[(2.0 / N[(t$95$m * N[Power[N[(N[(k / l), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $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 1.2 \cdot 10^{-62}:\\
\;\;\;\;\frac{2}{\frac{{\left(\frac{k}{\ell} \cdot \left(k \cdot \sqrt{t_m}\right)\right)}^{2}}{\cos k}}\\
\mathbf{elif}\;k \leq 1.1 \cdot 10^{+95}:\\
\;\;\;\;\frac{2}{\frac{\left(k \cdot \frac{k}{\ell}\right) \cdot \left(t_m \cdot {\sin k}^{2}\right)}{\ell \cdot \cos k}}\\
\mathbf{else}:\\
\;\;\;\;\cos k \cdot \frac{2}{t_m \cdot {\left(\frac{k}{\ell} \cdot \sin k\right)}^{2}}\\
\end{array}
\end{array}
if k < 1.19999999999999992e-62Initial program 38.3%
Taylor expanded in t around 0 74.9%
times-frac76.6%
Simplified76.6%
add-sqr-sqrt76.5%
sqrt-div76.5%
unpow276.5%
sqrt-prod24.2%
add-sqr-sqrt46.2%
pow246.2%
sqrt-prod25.1%
add-sqr-sqrt48.4%
sqrt-div48.4%
unpow248.4%
sqrt-prod10.1%
add-sqr-sqrt46.8%
pow246.8%
sqrt-prod44.1%
add-sqr-sqrt90.9%
Applied egg-rr90.9%
expm1-log1p-u76.3%
expm1-udef31.5%
Applied egg-rr25.5%
expm1-def30.8%
expm1-log1p35.8%
Simplified35.8%
Taylor expanded in k around 0 28.5%
if 1.19999999999999992e-62 < k < 1.0999999999999999e95Initial program 28.2%
Taylor expanded in t around 0 87.3%
times-frac87.6%
Simplified87.6%
add-sqr-sqrt87.6%
sqrt-div87.6%
unpow287.6%
sqrt-prod87.5%
add-sqr-sqrt87.6%
pow287.6%
sqrt-prod46.8%
add-sqr-sqrt56.7%
sqrt-div56.7%
unpow256.7%
sqrt-prod56.7%
add-sqr-sqrt56.7%
pow256.7%
sqrt-prod52.7%
add-sqr-sqrt96.5%
Applied egg-rr96.5%
associate-*r/96.6%
frac-times99.6%
Applied egg-rr99.6%
if 1.0999999999999999e95 < k Initial program 37.1%
Taylor expanded in t around 0 66.2%
times-frac74.0%
Simplified74.0%
add-sqr-sqrt74.1%
sqrt-div74.1%
unpow274.1%
sqrt-prod74.0%
add-sqr-sqrt74.1%
pow274.1%
sqrt-prod30.3%
add-sqr-sqrt59.4%
sqrt-div59.4%
unpow259.4%
sqrt-prod59.5%
add-sqr-sqrt59.6%
pow259.6%
sqrt-prod34.7%
add-sqr-sqrt97.5%
Applied egg-rr97.5%
expm1-log1p-u68.0%
expm1-udef51.1%
Applied egg-rr31.9%
expm1-def42.2%
expm1-log1p51.8%
Simplified51.8%
associate-/r/51.8%
associate-*r*51.9%
unpow-prod-down49.8%
pow249.8%
add-sqr-sqrt97.7%
Applied egg-rr97.7%
Final simplification49.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 225.0)
(/ 2.0 (/ (pow (* (/ k l) (* k (sqrt t_m))) 2.0) (cos k)))
(* 2.0 (* (* (/ l k) (/ l k)) (/ (cos k) (* t_m (pow (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 <= 225.0) {
tmp = 2.0 / (pow(((k / l) * (k * sqrt(t_m))), 2.0) / cos(k));
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / (t_m * pow(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 <= 225.0d0) then
tmp = 2.0d0 / ((((k / l) * (k * sqrt(t_m))) ** 2.0d0) / cos(k))
else
tmp = 2.0d0 * (((l / k) * (l / k)) * (cos(k) / (t_m * (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 <= 225.0) {
tmp = 2.0 / (Math.pow(((k / l) * (k * Math.sqrt(t_m))), 2.0) / Math.cos(k));
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (Math.cos(k) / (t_m * Math.pow(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 <= 225.0: tmp = 2.0 / (math.pow(((k / l) * (k * math.sqrt(t_m))), 2.0) / math.cos(k)) else: tmp = 2.0 * (((l / k) * (l / k)) * (math.cos(k) / (t_m * math.pow(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 <= 225.0) tmp = Float64(2.0 / Float64((Float64(Float64(k / l) * Float64(k * sqrt(t_m))) ^ 2.0) / cos(k))); else tmp = Float64(2.0 * Float64(Float64(Float64(l / k) * Float64(l / k)) * Float64(cos(k) / Float64(t_m * (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 <= 225.0) tmp = 2.0 / ((((k / l) * (k * sqrt(t_m))) ^ 2.0) / cos(k)); else tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / (t_m * (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, 225.0], N[(2.0 / N[(N[Power[N[(N[(k / l), $MachinePrecision] * N[(k * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / N[(t$95$m * N[Power[N[Sin[k], $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}\;k \leq 225:\\
\;\;\;\;\frac{2}{\frac{{\left(\frac{k}{\ell} \cdot \left(k \cdot \sqrt{t_m}\right)\right)}^{2}}{\cos k}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\left(\frac{\ell}{k} \cdot \frac{\ell}{k}\right) \cdot \frac{\cos k}{t_m \cdot {\sin k}^{2}}\right)\\
\end{array}
\end{array}
if k < 225Initial program 38.3%
Taylor expanded in t around 0 76.1%
times-frac77.6%
Simplified77.6%
add-sqr-sqrt77.6%
sqrt-div77.6%
unpow277.6%
sqrt-prod28.8%
add-sqr-sqrt49.3%
pow249.3%
sqrt-prod27.0%
add-sqr-sqrt48.8%
sqrt-div48.8%
unpow248.8%
sqrt-prod13.1%
add-sqr-sqrt47.3%
pow247.3%
sqrt-prod44.8%
add-sqr-sqrt91.5%
Applied egg-rr91.5%
expm1-log1p-u75.8%
expm1-udef31.5%
Applied egg-rr25.9%
expm1-def31.3%
expm1-log1p36.0%
Simplified36.0%
Taylor expanded in k around 0 29.2%
if 225 < k Initial program 32.5%
associate-/r*32.5%
*-commutative32.5%
associate-*l*32.4%
associate-*l/32.5%
+-commutative32.5%
unpow232.5%
sqr-neg32.5%
distribute-frac-neg32.5%
distribute-frac-neg32.5%
unpow232.5%
associate--l+43.4%
metadata-eval43.4%
+-rgt-identity43.4%
unpow243.4%
distribute-frac-neg43.4%
distribute-frac-neg43.4%
Simplified43.4%
Taylor expanded in k around inf 71.4%
times-frac77.1%
Simplified77.1%
add-sqr-sqrt77.1%
sqrt-div77.1%
pow277.1%
sqrt-prod33.8%
add-sqr-sqrt59.1%
unpow259.1%
sqrt-prod59.1%
add-sqr-sqrt59.1%
sqrt-div59.1%
pow259.1%
sqrt-prod36.8%
add-sqr-sqrt83.4%
unpow283.4%
sqrt-prod96.5%
add-sqr-sqrt96.6%
Applied egg-rr96.6%
Final simplification46.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 2.2e-8)
(* 2.0 (pow (* (/ l k) (/ (pow t_m -0.5) k)) 2.0))
(* (cos k) (/ 2.0 (* t_m (pow (* (/ k l) (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 <= 2.2e-8) {
tmp = 2.0 * pow(((l / k) * (pow(t_m, -0.5) / k)), 2.0);
} else {
tmp = cos(k) * (2.0 / (t_m * pow(((k / l) * 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 <= 2.2d-8) then
tmp = 2.0d0 * (((l / k) * ((t_m ** (-0.5d0)) / k)) ** 2.0d0)
else
tmp = cos(k) * (2.0d0 / (t_m * (((k / l) * 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 <= 2.2e-8) {
tmp = 2.0 * Math.pow(((l / k) * (Math.pow(t_m, -0.5) / k)), 2.0);
} else {
tmp = Math.cos(k) * (2.0 / (t_m * Math.pow(((k / l) * 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 <= 2.2e-8: tmp = 2.0 * math.pow(((l / k) * (math.pow(t_m, -0.5) / k)), 2.0) else: tmp = math.cos(k) * (2.0 / (t_m * math.pow(((k / l) * 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 <= 2.2e-8) tmp = Float64(2.0 * (Float64(Float64(l / k) * Float64((t_m ^ -0.5) / k)) ^ 2.0)); else tmp = Float64(cos(k) * Float64(2.0 / Float64(t_m * (Float64(Float64(k / l) * 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 <= 2.2e-8) tmp = 2.0 * (((l / k) * ((t_m ^ -0.5) / k)) ^ 2.0); else tmp = cos(k) * (2.0 / (t_m * (((k / l) * 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, 2.2e-8], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] * N[(N[Power[t$95$m, -0.5], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(N[Cos[k], $MachinePrecision] * N[(2.0 / N[(t$95$m * N[Power[N[(N[(k / l), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $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 2.2 \cdot 10^{-8}:\\
\;\;\;\;2 \cdot {\left(\frac{\ell}{k} \cdot \frac{{t_m}^{-0.5}}{k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\cos k \cdot \frac{2}{t_m \cdot {\left(\frac{k}{\ell} \cdot \sin k\right)}^{2}}\\
\end{array}
\end{array}
if k < 2.1999999999999998e-8Initial program 37.6%
associate-/r*36.9%
*-commutative36.9%
associate-*l*36.9%
associate-*l/38.0%
+-commutative38.0%
unpow238.0%
sqr-neg38.0%
distribute-frac-neg38.0%
distribute-frac-neg38.0%
unpow238.0%
associate--l+43.6%
metadata-eval43.6%
+-rgt-identity43.6%
unpow243.6%
distribute-frac-neg43.6%
distribute-frac-neg43.6%
Simplified43.6%
Taylor expanded in k around 0 65.1%
*-commutative65.1%
associate-/r*62.9%
Simplified62.9%
add-sqr-sqrt31.8%
sqrt-div25.4%
sqrt-div19.4%
pow219.4%
sqrt-prod9.7%
add-sqr-sqrt13.0%
sqrt-pow113.0%
metadata-eval13.0%
sqrt-div13.0%
sqrt-div13.1%
pow213.1%
sqrt-prod10.8%
add-sqr-sqrt24.2%
sqrt-pow126.8%
metadata-eval26.8%
Applied egg-rr26.8%
unpow226.8%
associate-/l/26.9%
Simplified26.9%
Taylor expanded in l around 0 27.8%
associate-*l/26.8%
Simplified26.8%
*-commutative26.8%
unpow226.8%
times-frac28.8%
inv-pow28.8%
sqrt-pow128.8%
metadata-eval28.8%
Applied egg-rr28.8%
if 2.1999999999999998e-8 < k Initial program 34.5%
Taylor expanded in t around 0 72.3%
times-frac77.7%
Simplified77.7%
add-sqr-sqrt77.8%
sqrt-div77.8%
unpow277.8%
sqrt-prod77.7%
add-sqr-sqrt77.8%
pow277.8%
sqrt-prod34.3%
add-sqr-sqrt58.8%
sqrt-div58.8%
unpow258.8%
sqrt-prod59.0%
add-sqr-sqrt59.0%
pow259.0%
sqrt-prod40.1%
add-sqr-sqrt96.7%
Applied egg-rr96.7%
expm1-log1p-u70.4%
expm1-udef43.6%
Applied egg-rr28.8%
expm1-def43.9%
expm1-log1p54.9%
Simplified54.9%
associate-/r/54.9%
associate-*r*54.9%
unpow-prod-down52.1%
pow252.1%
add-sqr-sqrt96.9%
Applied egg-rr96.9%
Final simplification46.6%
t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
:precision binary64
(*
t_s
(if (<= k 225.0)
(/ 2.0 (/ (pow (* (/ k l) (* k (sqrt t_m))) 2.0) (cos k)))
(* (cos k) (/ 2.0 (* t_m (pow (* (/ k l) (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 <= 225.0) {
tmp = 2.0 / (pow(((k / l) * (k * sqrt(t_m))), 2.0) / cos(k));
} else {
tmp = cos(k) * (2.0 / (t_m * pow(((k / l) * 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 <= 225.0d0) then
tmp = 2.0d0 / ((((k / l) * (k * sqrt(t_m))) ** 2.0d0) / cos(k))
else
tmp = cos(k) * (2.0d0 / (t_m * (((k / l) * 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 <= 225.0) {
tmp = 2.0 / (Math.pow(((k / l) * (k * Math.sqrt(t_m))), 2.0) / Math.cos(k));
} else {
tmp = Math.cos(k) * (2.0 / (t_m * Math.pow(((k / l) * 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 <= 225.0: tmp = 2.0 / (math.pow(((k / l) * (k * math.sqrt(t_m))), 2.0) / math.cos(k)) else: tmp = math.cos(k) * (2.0 / (t_m * math.pow(((k / l) * 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 <= 225.0) tmp = Float64(2.0 / Float64((Float64(Float64(k / l) * Float64(k * sqrt(t_m))) ^ 2.0) / cos(k))); else tmp = Float64(cos(k) * Float64(2.0 / Float64(t_m * (Float64(Float64(k / l) * 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 <= 225.0) tmp = 2.0 / ((((k / l) * (k * sqrt(t_m))) ^ 2.0) / cos(k)); else tmp = cos(k) * (2.0 / (t_m * (((k / l) * 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, 225.0], N[(2.0 / N[(N[Power[N[(N[(k / l), $MachinePrecision] * N[(k * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Cos[k], $MachinePrecision] * N[(2.0 / N[(t$95$m * N[Power[N[(N[(k / l), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $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 225:\\
\;\;\;\;\frac{2}{\frac{{\left(\frac{k}{\ell} \cdot \left(k \cdot \sqrt{t_m}\right)\right)}^{2}}{\cos k}}\\
\mathbf{else}:\\
\;\;\;\;\cos k \cdot \frac{2}{t_m \cdot {\left(\frac{k}{\ell} \cdot \sin k\right)}^{2}}\\
\end{array}
\end{array}
if k < 225Initial program 38.3%
Taylor expanded in t around 0 76.1%
times-frac77.6%
Simplified77.6%
add-sqr-sqrt77.6%
sqrt-div77.6%
unpow277.6%
sqrt-prod28.8%
add-sqr-sqrt49.3%
pow249.3%
sqrt-prod27.0%
add-sqr-sqrt48.8%
sqrt-div48.8%
unpow248.8%
sqrt-prod13.1%
add-sqr-sqrt47.3%
pow247.3%
sqrt-prod44.8%
add-sqr-sqrt91.5%
Applied egg-rr91.5%
expm1-log1p-u75.8%
expm1-udef31.5%
Applied egg-rr25.9%
expm1-def31.3%
expm1-log1p36.0%
Simplified36.0%
Taylor expanded in k around 0 29.2%
if 225 < k Initial program 32.5%
Taylor expanded in t around 0 71.4%
times-frac77.1%
Simplified77.1%
add-sqr-sqrt77.1%
sqrt-div77.1%
unpow277.1%
sqrt-prod77.1%
add-sqr-sqrt77.1%
pow277.1%
sqrt-prod33.8%
add-sqr-sqrt59.1%
sqrt-div59.1%
unpow259.1%
sqrt-prod59.2%
add-sqr-sqrt59.2%
pow259.2%
sqrt-prod39.8%
add-sqr-sqrt96.6%
Applied egg-rr96.6%
expm1-log1p-u69.5%
expm1-udef43.4%
Applied egg-rr28.2%
expm1-def43.7%
expm1-log1p55.0%
Simplified55.0%
associate-/r/55.1%
associate-*r*55.1%
unpow-prod-down52.1%
pow252.1%
add-sqr-sqrt96.8%
Applied egg-rr96.8%
Final simplification46.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 2.2e-8)
(* 2.0 (pow (* (/ l k) (/ (pow t_m -0.5) k)) 2.0))
(/
2.0
(*
(* (/ k l) (/ k l))
(/ (* t_m (- 0.5 (/ (cos (* 2.0 k)) 2.0))) (cos 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 (k <= 2.2e-8) {
tmp = 2.0 * pow(((l / k) * (pow(t_m, -0.5) / k)), 2.0);
} else {
tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * (0.5 - (cos((2.0 * k)) / 2.0))) / cos(k)));
}
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.2d-8) then
tmp = 2.0d0 * (((l / k) * ((t_m ** (-0.5d0)) / k)) ** 2.0d0)
else
tmp = 2.0d0 / (((k / l) * (k / l)) * ((t_m * (0.5d0 - (cos((2.0d0 * k)) / 2.0d0))) / cos(k)))
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.2e-8) {
tmp = 2.0 * Math.pow(((l / k) * (Math.pow(t_m, -0.5) / k)), 2.0);
} else {
tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * (0.5 - (Math.cos((2.0 * k)) / 2.0))) / Math.cos(k)));
}
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.2e-8: tmp = 2.0 * math.pow(((l / k) * (math.pow(t_m, -0.5) / k)), 2.0) else: tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * (0.5 - (math.cos((2.0 * k)) / 2.0))) / math.cos(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 (k <= 2.2e-8) tmp = Float64(2.0 * (Float64(Float64(l / k) * Float64((t_m ^ -0.5) / k)) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(Float64(k / l) * Float64(k / l)) * Float64(Float64(t_m * Float64(0.5 - Float64(cos(Float64(2.0 * k)) / 2.0))) / cos(k)))); 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.2e-8) tmp = 2.0 * (((l / k) * ((t_m ^ -0.5) / k)) ^ 2.0); else tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * (0.5 - (cos((2.0 * k)) / 2.0))) / cos(k))); 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.2e-8], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] * N[(N[Power[t$95$m, -0.5], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(k / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$m * N[(0.5 - N[(N[Cos[N[(2.0 * k), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[k], $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 2.2 \cdot 10^{-8}:\\
\;\;\;\;2 \cdot {\left(\frac{\ell}{k} \cdot \frac{{t_m}^{-0.5}}{k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\frac{k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \frac{t_m \cdot \left(0.5 - \frac{\cos \left(2 \cdot k\right)}{2}\right)}{\cos k}}\\
\end{array}
\end{array}
if k < 2.1999999999999998e-8Initial program 37.6%
associate-/r*36.9%
*-commutative36.9%
associate-*l*36.9%
associate-*l/38.0%
+-commutative38.0%
unpow238.0%
sqr-neg38.0%
distribute-frac-neg38.0%
distribute-frac-neg38.0%
unpow238.0%
associate--l+43.6%
metadata-eval43.6%
+-rgt-identity43.6%
unpow243.6%
distribute-frac-neg43.6%
distribute-frac-neg43.6%
Simplified43.6%
Taylor expanded in k around 0 65.1%
*-commutative65.1%
associate-/r*62.9%
Simplified62.9%
add-sqr-sqrt31.8%
sqrt-div25.4%
sqrt-div19.4%
pow219.4%
sqrt-prod9.7%
add-sqr-sqrt13.0%
sqrt-pow113.0%
metadata-eval13.0%
sqrt-div13.0%
sqrt-div13.1%
pow213.1%
sqrt-prod10.8%
add-sqr-sqrt24.2%
sqrt-pow126.8%
metadata-eval26.8%
Applied egg-rr26.8%
unpow226.8%
associate-/l/26.9%
Simplified26.9%
Taylor expanded in l around 0 27.8%
associate-*l/26.8%
Simplified26.8%
*-commutative26.8%
unpow226.8%
times-frac28.8%
inv-pow28.8%
sqrt-pow128.8%
metadata-eval28.8%
Applied egg-rr28.8%
if 2.1999999999999998e-8 < k Initial program 34.5%
Taylor expanded in t around 0 72.3%
times-frac77.7%
Simplified77.7%
add-sqr-sqrt77.8%
sqrt-div77.8%
unpow277.8%
sqrt-prod77.7%
add-sqr-sqrt77.8%
pow277.8%
sqrt-prod34.3%
add-sqr-sqrt58.8%
sqrt-div58.8%
unpow258.8%
sqrt-prod59.0%
add-sqr-sqrt59.0%
pow259.0%
sqrt-prod40.1%
add-sqr-sqrt96.7%
Applied egg-rr96.7%
unpow296.7%
sin-mult96.1%
Applied egg-rr96.1%
div-sub96.1%
+-inverses96.1%
cos-096.1%
metadata-eval96.1%
count-296.1%
*-commutative96.1%
Simplified96.1%
Final simplification46.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 1.15e-44)
(* 2.0 (pow (* (/ l k) (/ (pow t_m -0.5) k)) 2.0))
(/ 2.0 (* (* (/ k l) (/ k l)) (/ (* t_m (pow k 2.0)) (cos 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 (k <= 1.15e-44) {
tmp = 2.0 * pow(((l / k) * (pow(t_m, -0.5) / k)), 2.0);
} else {
tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * pow(k, 2.0)) / cos(k)));
}
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.15d-44) then
tmp = 2.0d0 * (((l / k) * ((t_m ** (-0.5d0)) / k)) ** 2.0d0)
else
tmp = 2.0d0 / (((k / l) * (k / l)) * ((t_m * (k ** 2.0d0)) / cos(k)))
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.15e-44) {
tmp = 2.0 * Math.pow(((l / k) * (Math.pow(t_m, -0.5) / k)), 2.0);
} else {
tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * Math.pow(k, 2.0)) / Math.cos(k)));
}
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.15e-44: tmp = 2.0 * math.pow(((l / k) * (math.pow(t_m, -0.5) / k)), 2.0) else: tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * math.pow(k, 2.0)) / math.cos(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 (k <= 1.15e-44) tmp = Float64(2.0 * (Float64(Float64(l / k) * Float64((t_m ^ -0.5) / k)) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(Float64(k / l) * Float64(k / l)) * Float64(Float64(t_m * (k ^ 2.0)) / cos(k)))); 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.15e-44) tmp = 2.0 * (((l / k) * ((t_m ^ -0.5) / k)) ^ 2.0); else tmp = 2.0 / (((k / l) * (k / l)) * ((t_m * (k ^ 2.0)) / cos(k))); 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.15e-44], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] * N[(N[Power[t$95$m, -0.5], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(k / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$m * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Cos[k], $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 1.15 \cdot 10^{-44}:\\
\;\;\;\;2 \cdot {\left(\frac{\ell}{k} \cdot \frac{{t_m}^{-0.5}}{k}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(\frac{k}{\ell} \cdot \frac{k}{\ell}\right) \cdot \frac{t_m \cdot {k}^{2}}{\cos k}}\\
\end{array}
\end{array}
if k < 1.14999999999999999e-44Initial program 38.1%
associate-/r*37.3%
*-commutative37.3%
associate-*l*37.3%
associate-*l/38.4%
+-commutative38.4%
unpow238.4%
sqr-neg38.4%
distribute-frac-neg38.4%
distribute-frac-neg38.4%
unpow238.4%
associate--l+43.8%
metadata-eval43.8%
+-rgt-identity43.8%
unpow243.8%
distribute-frac-neg43.8%
distribute-frac-neg43.8%
Simplified43.8%
Taylor expanded in k around 0 63.2%
*-commutative63.2%
associate-/r*61.3%
Simplified61.3%
add-sqr-sqrt30.8%
sqrt-div24.0%
sqrt-div18.2%
pow218.2%
sqrt-prod9.1%
add-sqr-sqrt12.7%
sqrt-pow112.7%
metadata-eval12.7%
sqrt-div12.7%
sqrt-div12.7%
pow212.7%
sqrt-prod10.2%
add-sqr-sqrt23.4%
sqrt-pow126.1%
metadata-eval26.1%
Applied egg-rr26.1%
unpow226.1%
associate-/l/26.2%
Simplified26.2%
Taylor expanded in l around 0 27.2%
associate-*l/26.1%
Simplified26.1%
*-commutative26.1%
unpow226.1%
times-frac28.2%
inv-pow28.2%
sqrt-pow128.2%
metadata-eval28.2%
Applied egg-rr28.2%
if 1.14999999999999999e-44 < k Initial program 33.9%
Taylor expanded in t around 0 75.8%
times-frac80.5%
Simplified80.5%
add-sqr-sqrt80.6%
sqrt-div80.6%
unpow280.6%
sqrt-prod80.5%
add-sqr-sqrt80.6%
pow280.6%
sqrt-prod37.6%
add-sqr-sqrt59.0%
sqrt-div59.0%
unpow259.0%
sqrt-prod59.1%
add-sqr-sqrt59.1%
pow259.1%
sqrt-prod42.6%
add-sqr-sqrt97.0%
Applied egg-rr97.0%
Taylor expanded in k around 0 63.1%
Final simplification38.7%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (* 2.0 (pow (* (/ l k) (/ (pow t_m -0.5) 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) {
return t_s * (2.0 * pow(((l / k) * (pow(t_m, -0.5) / k)), 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 * (2.0d0 * (((l / k) * ((t_m ** (-0.5d0)) / k)) ** 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 * (2.0 * Math.pow(((l / k) * (Math.pow(t_m, -0.5) / k)), 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 * (2.0 * math.pow(((l / k) * (math.pow(t_m, -0.5) / k)), 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(2.0 * (Float64(Float64(l / k) * Float64((t_m ^ -0.5) / k)) ^ 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 * (2.0 * (((l / k) * ((t_m ^ -0.5) / k)) ^ 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[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] * N[(N[Power[t$95$m, -0.5], $MachinePrecision] / k), $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 \left(2 \cdot {\left(\frac{\ell}{k} \cdot \frac{{t_m}^{-0.5}}{k}\right)}^{2}\right)
\end{array}
Initial program 36.8%
associate-/r*36.3%
*-commutative36.3%
associate-*l*36.3%
associate-*l/37.1%
+-commutative37.1%
unpow237.1%
sqr-neg37.1%
distribute-frac-neg37.1%
distribute-frac-neg37.1%
unpow237.1%
associate--l+44.0%
metadata-eval44.0%
+-rgt-identity44.0%
unpow244.0%
distribute-frac-neg44.0%
distribute-frac-neg44.0%
Simplified44.0%
Taylor expanded in k around 0 62.1%
*-commutative62.1%
associate-/r*60.4%
Simplified60.4%
add-sqr-sqrt36.7%
sqrt-div29.0%
sqrt-div21.1%
pow221.1%
sqrt-prod10.7%
add-sqr-sqrt16.4%
sqrt-pow116.4%
metadata-eval16.4%
sqrt-div16.4%
sqrt-div16.1%
pow216.1%
sqrt-prod11.5%
add-sqr-sqrt24.4%
sqrt-pow126.3%
metadata-eval26.3%
Applied egg-rr26.3%
unpow226.3%
associate-/l/26.4%
Simplified26.4%
Taylor expanded in l around 0 27.1%
associate-*l/26.3%
Simplified26.3%
*-commutative26.3%
unpow226.3%
times-frac27.9%
inv-pow27.9%
sqrt-pow127.9%
metadata-eval27.9%
Applied egg-rr27.9%
Final simplification27.9%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (* 2.0 (/ (* (/ l (pow k 2.0)) (* (/ l k) (/ 1.0 k))) t_m))))
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 * (2.0 * (((l / pow(k, 2.0)) * ((l / k) * (1.0 / k))) / t_m));
}
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 * (2.0d0 * (((l / (k ** 2.0d0)) * ((l / k) * (1.0d0 / k))) / t_m))
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 * (2.0 * (((l / Math.pow(k, 2.0)) * ((l / k) * (1.0 / k))) / t_m));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * (2.0 * (((l / math.pow(k, 2.0)) * ((l / k) * (1.0 / k))) / t_m))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(2.0 * Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(Float64(l / k) * Float64(1.0 / k))) / t_m))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * (2.0 * (((l / (k ^ 2.0)) * ((l / k) * (1.0 / k))) / t_m)); 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[(2.0 * N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] * N[(1.0 / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t_s \cdot \left(2 \cdot \frac{\frac{\ell}{{k}^{2}} \cdot \left(\frac{\ell}{k} \cdot \frac{1}{k}\right)}{t_m}\right)
\end{array}
Initial program 36.8%
associate-/r*36.3%
*-commutative36.3%
associate-*l*36.3%
associate-*l/37.1%
+-commutative37.1%
unpow237.1%
sqr-neg37.1%
distribute-frac-neg37.1%
distribute-frac-neg37.1%
unpow237.1%
associate--l+44.0%
metadata-eval44.0%
+-rgt-identity44.0%
unpow244.0%
distribute-frac-neg44.0%
distribute-frac-neg44.0%
Simplified44.0%
Taylor expanded in k around 0 62.1%
*-commutative62.1%
associate-/r*60.4%
Simplified60.4%
add-sqr-sqrt36.7%
sqrt-div29.0%
sqrt-div21.1%
pow221.1%
sqrt-prod10.7%
add-sqr-sqrt16.4%
sqrt-pow116.4%
metadata-eval16.4%
sqrt-div16.4%
sqrt-div16.1%
pow216.1%
sqrt-prod11.5%
add-sqr-sqrt24.4%
sqrt-pow126.3%
metadata-eval26.3%
Applied egg-rr26.3%
unpow226.3%
associate-/l/26.4%
Simplified26.4%
unpow226.4%
associate-/r*26.4%
associate-/r*27.1%
frac-times27.5%
add-sqr-sqrt72.3%
Applied egg-rr72.3%
*-un-lft-identity72.3%
unpow272.3%
times-frac72.3%
Applied egg-rr72.3%
Final simplification72.3%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (* 2.0 (* (/ l (pow k 4.0)) (/ l t_m)))))
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 * (2.0 * ((l / pow(k, 4.0)) * (l / t_m)));
}
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 * (2.0d0 * ((l / (k ** 4.0d0)) * (l / t_m)))
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 * (2.0 * ((l / Math.pow(k, 4.0)) * (l / t_m)));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * (2.0 * ((l / math.pow(k, 4.0)) * (l / t_m)))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(2.0 * Float64(Float64(l / (k ^ 4.0)) * Float64(l / t_m)))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * (2.0 * ((l / (k ^ 4.0)) * (l / t_m))); 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[(2.0 * N[(N[(l / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] * N[(l / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t_s \cdot \left(2 \cdot \left(\frac{\ell}{{k}^{4}} \cdot \frac{\ell}{t_m}\right)\right)
\end{array}
Initial program 36.8%
associate-/r*36.3%
*-commutative36.3%
associate-*l*36.3%
associate-*l/37.1%
+-commutative37.1%
unpow237.1%
sqr-neg37.1%
distribute-frac-neg37.1%
distribute-frac-neg37.1%
unpow237.1%
associate--l+44.0%
metadata-eval44.0%
+-rgt-identity44.0%
unpow244.0%
distribute-frac-neg44.0%
distribute-frac-neg44.0%
Simplified44.0%
Taylor expanded in k around 0 62.1%
*-commutative62.1%
associate-/r*60.4%
Simplified60.4%
pow260.4%
Applied egg-rr60.4%
associate-/l/62.1%
times-frac68.4%
Applied egg-rr68.4%
Final simplification68.4%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (* 2.0 (/ (* l (pow k -4.0)) (/ t_m l)))))
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 * (2.0 * ((l * pow(k, -4.0)) / (t_m / l)));
}
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 * (2.0d0 * ((l * (k ** (-4.0d0))) / (t_m / l)))
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 * (2.0 * ((l * Math.pow(k, -4.0)) / (t_m / l)));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * (2.0 * ((l * math.pow(k, -4.0)) / (t_m / l)))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(2.0 * Float64(Float64(l * (k ^ -4.0)) / Float64(t_m / l)))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * (2.0 * ((l * (k ^ -4.0)) / (t_m / l))); 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[(2.0 * N[(N[(l * N[Power[k, -4.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$m / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t_s \cdot \left(2 \cdot \frac{\ell \cdot {k}^{-4}}{\frac{t_m}{\ell}}\right)
\end{array}
Initial program 36.8%
associate-/r*36.3%
*-commutative36.3%
associate-*l*36.3%
associate-*l/37.1%
+-commutative37.1%
unpow237.1%
sqr-neg37.1%
distribute-frac-neg37.1%
distribute-frac-neg37.1%
unpow237.1%
associate--l+44.0%
metadata-eval44.0%
+-rgt-identity44.0%
unpow244.0%
distribute-frac-neg44.0%
distribute-frac-neg44.0%
Simplified44.0%
Taylor expanded in k around 0 62.1%
*-commutative62.1%
associate-/r*60.4%
Simplified60.4%
pow260.4%
Applied egg-rr60.4%
associate-/l/62.1%
times-frac68.4%
Applied egg-rr68.4%
associate-*r/69.3%
div-inv69.3%
pow-flip69.3%
metadata-eval69.3%
Applied egg-rr69.3%
associate-/l*68.8%
Simplified68.8%
Final simplification68.8%
t_m = (fabs.f64 t) t_s = (copysign.f64 1 t) (FPCore (t_s t_m l k) :precision binary64 (* t_s (* 2.0 (/ (/ l (/ (pow k 4.0) l)) t_m))))
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 * (2.0 * ((l / (pow(k, 4.0) / l)) / t_m));
}
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 * (2.0d0 * ((l / ((k ** 4.0d0) / l)) / t_m))
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 * (2.0 * ((l / (Math.pow(k, 4.0) / l)) / t_m));
}
t_m = math.fabs(t) t_s = math.copysign(1.0, t) def code(t_s, t_m, l, k): return t_s * (2.0 * ((l / (math.pow(k, 4.0) / l)) / t_m))
t_m = abs(t) t_s = copysign(1.0, t) function code(t_s, t_m, l, k) return Float64(t_s * Float64(2.0 * Float64(Float64(l / Float64((k ^ 4.0) / l)) / t_m))) end
t_m = abs(t); t_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k) tmp = t_s * (2.0 * ((l / ((k ^ 4.0) / l)) / t_m)); 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[(2.0 * N[(N[(l / N[(N[Power[k, 4.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
t_s = \mathsf{copysign}\left(1, t\right)
\\
t_s \cdot \left(2 \cdot \frac{\frac{\ell}{\frac{{k}^{4}}{\ell}}}{t_m}\right)
\end{array}
Initial program 36.8%
associate-/r*36.3%
*-commutative36.3%
associate-*l*36.3%
associate-*l/37.1%
+-commutative37.1%
unpow237.1%
sqr-neg37.1%
distribute-frac-neg37.1%
distribute-frac-neg37.1%
unpow237.1%
associate--l+44.0%
metadata-eval44.0%
+-rgt-identity44.0%
unpow244.0%
distribute-frac-neg44.0%
distribute-frac-neg44.0%
Simplified44.0%
Taylor expanded in k around 0 62.1%
*-commutative62.1%
associate-/r*60.4%
Simplified60.4%
add-sqr-sqrt36.7%
sqrt-div29.0%
sqrt-div21.1%
pow221.1%
sqrt-prod10.7%
add-sqr-sqrt16.4%
sqrt-pow116.4%
metadata-eval16.4%
sqrt-div16.4%
sqrt-div16.1%
pow216.1%
sqrt-prod11.5%
add-sqr-sqrt24.4%
sqrt-pow126.3%
metadata-eval26.3%
Applied egg-rr26.3%
unpow226.3%
associate-/l/26.4%
Simplified26.4%
unpow226.4%
associate-/r*26.4%
associate-/r*27.1%
frac-times27.5%
add-sqr-sqrt72.3%
Applied egg-rr72.3%
clear-num72.3%
unpow272.3%
associate-*l/72.3%
frac-times71.6%
*-un-lft-identity71.6%
associate-*l/71.6%
unpow271.6%
Applied egg-rr71.6%
associate-*l/69.3%
pow-sqr69.3%
metadata-eval69.3%
Simplified69.3%
Final simplification69.3%
herbie shell --seed 2023318
(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))))