
(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 14 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}
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= k_m 6.5e+29)
(*
2.0
(pow (/ (/ (* l (sqrt (cos k_m))) k_m) (* (sin k_m) (sqrt t_m))) 2.0))
(*
2.0
(* (/ (cos k_m) (* t_m (pow (sin k_m) 2.0))) (pow (/ l k_m) 2.0))))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 6.5e+29) {
tmp = 2.0 * pow((((l * sqrt(cos(k_m))) / k_m) / (sin(k_m) * sqrt(t_m))), 2.0);
} else {
tmp = 2.0 * ((cos(k_m) / (t_m * pow(sin(k_m), 2.0))) * pow((l / k_m), 2.0));
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 6.5d+29) then
tmp = 2.0d0 * ((((l * sqrt(cos(k_m))) / k_m) / (sin(k_m) * sqrt(t_m))) ** 2.0d0)
else
tmp = 2.0d0 * ((cos(k_m) / (t_m * (sin(k_m) ** 2.0d0))) * ((l / k_m) ** 2.0d0))
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
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_m) {
double tmp;
if (k_m <= 6.5e+29) {
tmp = 2.0 * Math.pow((((l * Math.sqrt(Math.cos(k_m))) / k_m) / (Math.sin(k_m) * Math.sqrt(t_m))), 2.0);
} else {
tmp = 2.0 * ((Math.cos(k_m) / (t_m * Math.pow(Math.sin(k_m), 2.0))) * Math.pow((l / k_m), 2.0));
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if k_m <= 6.5e+29: tmp = 2.0 * math.pow((((l * math.sqrt(math.cos(k_m))) / k_m) / (math.sin(k_m) * math.sqrt(t_m))), 2.0) else: tmp = 2.0 * ((math.cos(k_m) / (t_m * math.pow(math.sin(k_m), 2.0))) * math.pow((l / k_m), 2.0)) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (k_m <= 6.5e+29) tmp = Float64(2.0 * (Float64(Float64(Float64(l * sqrt(cos(k_m))) / k_m) / Float64(sin(k_m) * sqrt(t_m))) ^ 2.0)); else tmp = Float64(2.0 * Float64(Float64(cos(k_m) / Float64(t_m * (sin(k_m) ^ 2.0))) * (Float64(l / k_m) ^ 2.0))); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if (k_m <= 6.5e+29) tmp = 2.0 * ((((l * sqrt(cos(k_m))) / k_m) / (sin(k_m) * sqrt(t_m))) ^ 2.0); else tmp = 2.0 * ((cos(k_m) / (t_m * (sin(k_m) ^ 2.0))) * ((l / k_m) ^ 2.0)); end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 6.5e+29], N[(2.0 * N[Power[N[(N[(N[(l * N[Sqrt[N[Cos[k$95$m], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / k$95$m), $MachinePrecision] / N[(N[Sin[k$95$m], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Cos[k$95$m], $MachinePrecision] / N[(t$95$m * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[(l / k$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 6.5 \cdot 10^{+29}:\\
\;\;\;\;2 \cdot {\left(\frac{\frac{\ell \cdot \sqrt{\cos k\_m}}{k\_m}}{\sin k\_m \cdot \sqrt{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k\_m}{t\_m \cdot {\sin k\_m}^{2}} \cdot {\left(\frac{\ell}{k\_m}\right)}^{2}\right)\\
\end{array}
\end{array}
if k < 6.49999999999999971e29Initial program 35.6%
*-commutative35.6%
associate-/r*35.7%
Simplified43.3%
unpow343.3%
times-frac55.7%
pow255.7%
Applied egg-rr55.7%
Taylor expanded in k around inf 68.9%
associate-/r*70.5%
Simplified70.5%
add-sqr-sqrt48.0%
pow248.0%
Applied egg-rr47.8%
if 6.49999999999999971e29 < k Initial program 42.9%
*-commutative42.9%
associate-/r*42.9%
Simplified57.2%
unpow357.2%
times-frac64.4%
pow264.4%
Applied egg-rr64.4%
Taylor expanded in k around inf 75.5%
associate-/r*74.0%
Simplified74.0%
associate-/l/75.5%
*-commutative75.5%
times-frac74.0%
pow274.0%
unpow274.0%
frac-times87.8%
pow287.8%
Applied egg-rr87.8%
Final simplification56.6%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= (* l l) 5e-244)
(pow (/ (* (pow t_m -0.5) (/ (* l (sqrt 2.0)) k_m)) (sin k_m)) 2.0)
(*
2.0
(* (/ (cos k_m) (* t_m (pow (sin k_m) 2.0))) (pow (/ l k_m) 2.0))))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if ((l * l) <= 5e-244) {
tmp = pow(((pow(t_m, -0.5) * ((l * sqrt(2.0)) / k_m)) / sin(k_m)), 2.0);
} else {
tmp = 2.0 * ((cos(k_m) / (t_m * pow(sin(k_m), 2.0))) * pow((l / k_m), 2.0));
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if ((l * l) <= 5d-244) then
tmp = (((t_m ** (-0.5d0)) * ((l * sqrt(2.0d0)) / k_m)) / sin(k_m)) ** 2.0d0
else
tmp = 2.0d0 * ((cos(k_m) / (t_m * (sin(k_m) ** 2.0d0))) * ((l / k_m) ** 2.0d0))
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
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_m) {
double tmp;
if ((l * l) <= 5e-244) {
tmp = Math.pow(((Math.pow(t_m, -0.5) * ((l * Math.sqrt(2.0)) / k_m)) / Math.sin(k_m)), 2.0);
} else {
tmp = 2.0 * ((Math.cos(k_m) / (t_m * Math.pow(Math.sin(k_m), 2.0))) * Math.pow((l / k_m), 2.0));
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if (l * l) <= 5e-244: tmp = math.pow(((math.pow(t_m, -0.5) * ((l * math.sqrt(2.0)) / k_m)) / math.sin(k_m)), 2.0) else: tmp = 2.0 * ((math.cos(k_m) / (t_m * math.pow(math.sin(k_m), 2.0))) * math.pow((l / k_m), 2.0)) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (Float64(l * l) <= 5e-244) tmp = Float64(Float64((t_m ^ -0.5) * Float64(Float64(l * sqrt(2.0)) / k_m)) / sin(k_m)) ^ 2.0; else tmp = Float64(2.0 * Float64(Float64(cos(k_m) / Float64(t_m * (sin(k_m) ^ 2.0))) * (Float64(l / k_m) ^ 2.0))); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if ((l * l) <= 5e-244) tmp = (((t_m ^ -0.5) * ((l * sqrt(2.0)) / k_m)) / sin(k_m)) ^ 2.0; else tmp = 2.0 * ((cos(k_m) / (t_m * (sin(k_m) ^ 2.0))) * ((l / k_m) ^ 2.0)); end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * If[LessEqual[N[(l * l), $MachinePrecision], 5e-244], N[Power[N[(N[(N[Power[t$95$m, -0.5], $MachinePrecision] * N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(2.0 * N[(N[(N[Cos[k$95$m], $MachinePrecision] / N[(t$95$m * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[(l / k$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\ell \cdot \ell \leq 5 \cdot 10^{-244}:\\
\;\;\;\;{\left(\frac{{t\_m}^{-0.5} \cdot \frac{\ell \cdot \sqrt{2}}{k\_m}}{\sin k\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k\_m}{t\_m \cdot {\sin k\_m}^{2}} \cdot {\left(\frac{\ell}{k\_m}\right)}^{2}\right)\\
\end{array}
\end{array}
if (*.f64 l l) < 4.99999999999999998e-244Initial program 19.4%
Simplified35.3%
add-sqr-sqrt31.6%
pow231.6%
Applied egg-rr32.5%
*-commutative32.5%
Simplified32.5%
Taylor expanded in l around 0 48.0%
*-commutative48.0%
associate-/r*51.4%
*-commutative51.4%
associate-/l*51.4%
Simplified51.4%
Taylor expanded in k around 0 59.1%
unpow1/259.1%
rem-exp-log58.0%
exp-neg58.0%
exp-prod58.0%
distribute-lft-neg-out58.0%
distribute-rgt-neg-in58.0%
metadata-eval58.0%
exp-to-pow59.0%
Simplified59.0%
associate-*r/59.1%
associate-*r/59.1%
Applied egg-rr59.1%
if 4.99999999999999998e-244 < (*.f64 l l) Initial program 45.7%
*-commutative45.7%
associate-/r*45.8%
Simplified52.0%
unpow352.0%
times-frac60.1%
pow260.1%
Applied egg-rr60.1%
Taylor expanded in k around inf 78.8%
associate-/r*80.0%
Simplified80.0%
associate-/l/78.8%
*-commutative78.8%
times-frac80.0%
pow280.0%
unpow280.0%
frac-times94.1%
pow294.1%
Applied egg-rr94.1%
Final simplification82.7%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= (* l l) 5e-244)
(pow (/ (* (pow t_m -0.5) (/ (* l (sqrt 2.0)) k_m)) (sin k_m)) 2.0)
(*
2.0
(/ (* (cos k_m) (pow (/ l k_m) 2.0)) (* t_m (pow (sin k_m) 2.0)))))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if ((l * l) <= 5e-244) {
tmp = pow(((pow(t_m, -0.5) * ((l * sqrt(2.0)) / k_m)) / sin(k_m)), 2.0);
} else {
tmp = 2.0 * ((cos(k_m) * pow((l / k_m), 2.0)) / (t_m * pow(sin(k_m), 2.0)));
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if ((l * l) <= 5d-244) then
tmp = (((t_m ** (-0.5d0)) * ((l * sqrt(2.0d0)) / k_m)) / sin(k_m)) ** 2.0d0
else
tmp = 2.0d0 * ((cos(k_m) * ((l / k_m) ** 2.0d0)) / (t_m * (sin(k_m) ** 2.0d0)))
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
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_m) {
double tmp;
if ((l * l) <= 5e-244) {
tmp = Math.pow(((Math.pow(t_m, -0.5) * ((l * Math.sqrt(2.0)) / k_m)) / Math.sin(k_m)), 2.0);
} else {
tmp = 2.0 * ((Math.cos(k_m) * Math.pow((l / k_m), 2.0)) / (t_m * Math.pow(Math.sin(k_m), 2.0)));
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if (l * l) <= 5e-244: tmp = math.pow(((math.pow(t_m, -0.5) * ((l * math.sqrt(2.0)) / k_m)) / math.sin(k_m)), 2.0) else: tmp = 2.0 * ((math.cos(k_m) * math.pow((l / k_m), 2.0)) / (t_m * math.pow(math.sin(k_m), 2.0))) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (Float64(l * l) <= 5e-244) tmp = Float64(Float64((t_m ^ -0.5) * Float64(Float64(l * sqrt(2.0)) / k_m)) / sin(k_m)) ^ 2.0; else tmp = Float64(2.0 * Float64(Float64(cos(k_m) * (Float64(l / k_m) ^ 2.0)) / Float64(t_m * (sin(k_m) ^ 2.0)))); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if ((l * l) <= 5e-244) tmp = (((t_m ^ -0.5) * ((l * sqrt(2.0)) / k_m)) / sin(k_m)) ^ 2.0; else tmp = 2.0 * ((cos(k_m) * ((l / k_m) ^ 2.0)) / (t_m * (sin(k_m) ^ 2.0))); end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * If[LessEqual[N[(l * l), $MachinePrecision], 5e-244], N[Power[N[(N[(N[Power[t$95$m, -0.5], $MachinePrecision] * N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(2.0 * N[(N[(N[Cos[k$95$m], $MachinePrecision] * N[Power[N[(l / k$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$m * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\ell \cdot \ell \leq 5 \cdot 10^{-244}:\\
\;\;\;\;{\left(\frac{{t\_m}^{-0.5} \cdot \frac{\ell \cdot \sqrt{2}}{k\_m}}{\sin k\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\cos k\_m \cdot {\left(\frac{\ell}{k\_m}\right)}^{2}}{t\_m \cdot {\sin k\_m}^{2}}\\
\end{array}
\end{array}
if (*.f64 l l) < 4.99999999999999998e-244Initial program 19.4%
Simplified35.3%
add-sqr-sqrt31.6%
pow231.6%
Applied egg-rr32.5%
*-commutative32.5%
Simplified32.5%
Taylor expanded in l around 0 48.0%
*-commutative48.0%
associate-/r*51.4%
*-commutative51.4%
associate-/l*51.4%
Simplified51.4%
Taylor expanded in k around 0 59.1%
unpow1/259.1%
rem-exp-log58.0%
exp-neg58.0%
exp-prod58.0%
distribute-lft-neg-out58.0%
distribute-rgt-neg-in58.0%
metadata-eval58.0%
exp-to-pow59.0%
Simplified59.0%
associate-*r/59.1%
associate-*r/59.1%
Applied egg-rr59.1%
if 4.99999999999999998e-244 < (*.f64 l l) Initial program 45.7%
*-commutative45.7%
associate-/r*45.8%
Simplified52.0%
unpow352.0%
times-frac60.1%
pow260.1%
Applied egg-rr60.1%
Taylor expanded in k around inf 78.8%
associate-/r*80.0%
Simplified80.0%
*-commutative80.0%
*-un-lft-identity80.0%
times-frac80.0%
pow280.0%
unpow280.0%
frac-times94.1%
pow294.1%
Applied egg-rr94.1%
/-rgt-identity94.1%
Simplified94.1%
Final simplification82.7%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (pow (* (pow t_m -0.5) (* l (/ (sqrt 2.0) (* k_m (sin k_m))))) 2.0)))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * pow((pow(t_m, -0.5) * (l * (sqrt(2.0) / (k_m * sin(k_m))))), 2.0);
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * (((t_m ** (-0.5d0)) * (l * (sqrt(2.0d0) / (k_m * sin(k_m))))) ** 2.0d0)
end function
k_m = Math.abs(k);
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_m) {
return t_s * Math.pow((Math.pow(t_m, -0.5) * (l * (Math.sqrt(2.0) / (k_m * Math.sin(k_m))))), 2.0);
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * math.pow((math.pow(t_m, -0.5) * (l * (math.sqrt(2.0) / (k_m * math.sin(k_m))))), 2.0)
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * (Float64((t_m ^ -0.5) * Float64(l * Float64(sqrt(2.0) / Float64(k_m * sin(k_m))))) ^ 2.0)) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * (((t_m ^ -0.5) * (l * (sqrt(2.0) / (k_m * sin(k_m))))) ^ 2.0); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[Power[N[(N[Power[t$95$m, -0.5], $MachinePrecision] * N[(l * N[(N[Sqrt[2.0], $MachinePrecision] / N[(k$95$m * N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot {\left({t\_m}^{-0.5} \cdot \left(\ell \cdot \frac{\sqrt{2}}{k\_m \cdot \sin k\_m}\right)\right)}^{2}
\end{array}
Initial program 37.2%
Simplified48.9%
add-sqr-sqrt35.6%
pow235.6%
Applied egg-rr31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in l around 0 52.1%
*-commutative52.1%
associate-/r*53.2%
*-commutative53.2%
associate-/l*53.3%
Simplified53.3%
Taylor expanded in k around 0 46.4%
unpow1/246.4%
rem-exp-log46.0%
exp-neg45.9%
exp-prod45.9%
distribute-lft-neg-out45.9%
distribute-rgt-neg-in45.9%
metadata-eval45.9%
exp-to-pow46.4%
Simplified46.4%
associate-*r/46.4%
associate-*r/46.4%
Applied egg-rr46.4%
associate-/l*46.4%
*-commutative46.4%
associate-/r*45.3%
associate-/l*45.3%
Simplified45.3%
Final simplification45.3%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (pow (* (pow t_m -0.5) (/ (* (/ l k_m) (sqrt 2.0)) (sin k_m))) 2.0)))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * pow((pow(t_m, -0.5) * (((l / k_m) * sqrt(2.0)) / sin(k_m))), 2.0);
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * (((t_m ** (-0.5d0)) * (((l / k_m) * sqrt(2.0d0)) / sin(k_m))) ** 2.0d0)
end function
k_m = Math.abs(k);
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_m) {
return t_s * Math.pow((Math.pow(t_m, -0.5) * (((l / k_m) * Math.sqrt(2.0)) / Math.sin(k_m))), 2.0);
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * math.pow((math.pow(t_m, -0.5) * (((l / k_m) * math.sqrt(2.0)) / math.sin(k_m))), 2.0)
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * (Float64((t_m ^ -0.5) * Float64(Float64(Float64(l / k_m) * sqrt(2.0)) / sin(k_m))) ^ 2.0)) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * (((t_m ^ -0.5) * (((l / k_m) * sqrt(2.0)) / sin(k_m))) ^ 2.0); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[Power[N[(N[Power[t$95$m, -0.5], $MachinePrecision] * N[(N[(N[(l / k$95$m), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot {\left({t\_m}^{-0.5} \cdot \frac{\frac{\ell}{k\_m} \cdot \sqrt{2}}{\sin k\_m}\right)}^{2}
\end{array}
Initial program 37.2%
Simplified48.9%
add-sqr-sqrt35.6%
pow235.6%
Applied egg-rr31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in l around 0 52.1%
*-commutative52.1%
associate-/r*53.2%
*-commutative53.2%
associate-/l*53.3%
Simplified53.3%
Taylor expanded in k around 0 46.4%
unpow1/246.4%
rem-exp-log46.0%
exp-neg45.9%
exp-prod45.9%
distribute-lft-neg-out45.9%
distribute-rgt-neg-in45.9%
metadata-eval45.9%
exp-to-pow46.4%
Simplified46.4%
Final simplification46.4%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (pow (/ (* (pow t_m -0.5) (/ (* l (sqrt 2.0)) k_m)) (sin k_m)) 2.0)))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * pow(((pow(t_m, -0.5) * ((l * sqrt(2.0)) / k_m)) / sin(k_m)), 2.0);
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((((t_m ** (-0.5d0)) * ((l * sqrt(2.0d0)) / k_m)) / sin(k_m)) ** 2.0d0)
end function
k_m = Math.abs(k);
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_m) {
return t_s * Math.pow(((Math.pow(t_m, -0.5) * ((l * Math.sqrt(2.0)) / k_m)) / Math.sin(k_m)), 2.0);
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * math.pow(((math.pow(t_m, -0.5) * ((l * math.sqrt(2.0)) / k_m)) / math.sin(k_m)), 2.0)
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * (Float64(Float64((t_m ^ -0.5) * Float64(Float64(l * sqrt(2.0)) / k_m)) / sin(k_m)) ^ 2.0)) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((((t_m ^ -0.5) * ((l * sqrt(2.0)) / k_m)) / sin(k_m)) ^ 2.0); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[Power[N[(N[(N[Power[t$95$m, -0.5], $MachinePrecision] * N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot {\left(\frac{{t\_m}^{-0.5} \cdot \frac{\ell \cdot \sqrt{2}}{k\_m}}{\sin k\_m}\right)}^{2}
\end{array}
Initial program 37.2%
Simplified48.9%
add-sqr-sqrt35.6%
pow235.6%
Applied egg-rr31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in l around 0 52.1%
*-commutative52.1%
associate-/r*53.2%
*-commutative53.2%
associate-/l*53.3%
Simplified53.3%
Taylor expanded in k around 0 46.4%
unpow1/246.4%
rem-exp-log46.0%
exp-neg45.9%
exp-prod45.9%
distribute-lft-neg-out45.9%
distribute-rgt-neg-in45.9%
metadata-eval45.9%
exp-to-pow46.4%
Simplified46.4%
associate-*r/46.4%
associate-*r/46.4%
Applied egg-rr46.4%
Final simplification46.4%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= k_m 9.5e+29)
(pow (* l (* (/ 1.0 k_m) (/ (sqrt (/ 2.0 t_m)) k_m))) 2.0)
(if (<= k_m 2.3e+156)
(/
(/ 2.0 (* (/ k_m t_m) (/ k_m t_m)))
(* (* (/ (pow t_m 2.0) l) (/ t_m l)) (* (sin k_m) (tan k_m))))
(* (/ 2.0 t_m) (pow (/ (/ l k_m) (sin k_m)) 2.0))))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 9.5e+29) {
tmp = pow((l * ((1.0 / k_m) * (sqrt((2.0 / t_m)) / k_m))), 2.0);
} else if (k_m <= 2.3e+156) {
tmp = (2.0 / ((k_m / t_m) * (k_m / t_m))) / (((pow(t_m, 2.0) / l) * (t_m / l)) * (sin(k_m) * tan(k_m)));
} else {
tmp = (2.0 / t_m) * pow(((l / k_m) / sin(k_m)), 2.0);
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 9.5d+29) then
tmp = (l * ((1.0d0 / k_m) * (sqrt((2.0d0 / t_m)) / k_m))) ** 2.0d0
else if (k_m <= 2.3d+156) then
tmp = (2.0d0 / ((k_m / t_m) * (k_m / t_m))) / ((((t_m ** 2.0d0) / l) * (t_m / l)) * (sin(k_m) * tan(k_m)))
else
tmp = (2.0d0 / t_m) * (((l / k_m) / sin(k_m)) ** 2.0d0)
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
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_m) {
double tmp;
if (k_m <= 9.5e+29) {
tmp = Math.pow((l * ((1.0 / k_m) * (Math.sqrt((2.0 / t_m)) / k_m))), 2.0);
} else if (k_m <= 2.3e+156) {
tmp = (2.0 / ((k_m / t_m) * (k_m / t_m))) / (((Math.pow(t_m, 2.0) / l) * (t_m / l)) * (Math.sin(k_m) * Math.tan(k_m)));
} else {
tmp = (2.0 / t_m) * Math.pow(((l / k_m) / Math.sin(k_m)), 2.0);
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if k_m <= 9.5e+29: tmp = math.pow((l * ((1.0 / k_m) * (math.sqrt((2.0 / t_m)) / k_m))), 2.0) elif k_m <= 2.3e+156: tmp = (2.0 / ((k_m / t_m) * (k_m / t_m))) / (((math.pow(t_m, 2.0) / l) * (t_m / l)) * (math.sin(k_m) * math.tan(k_m))) else: tmp = (2.0 / t_m) * math.pow(((l / k_m) / math.sin(k_m)), 2.0) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (k_m <= 9.5e+29) tmp = Float64(l * Float64(Float64(1.0 / k_m) * Float64(sqrt(Float64(2.0 / t_m)) / k_m))) ^ 2.0; elseif (k_m <= 2.3e+156) tmp = Float64(Float64(2.0 / Float64(Float64(k_m / t_m) * Float64(k_m / t_m))) / Float64(Float64(Float64((t_m ^ 2.0) / l) * Float64(t_m / l)) * Float64(sin(k_m) * tan(k_m)))); else tmp = Float64(Float64(2.0 / t_m) * (Float64(Float64(l / k_m) / sin(k_m)) ^ 2.0)); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if (k_m <= 9.5e+29) tmp = (l * ((1.0 / k_m) * (sqrt((2.0 / t_m)) / k_m))) ^ 2.0; elseif (k_m <= 2.3e+156) tmp = (2.0 / ((k_m / t_m) * (k_m / t_m))) / ((((t_m ^ 2.0) / l) * (t_m / l)) * (sin(k_m) * tan(k_m))); else tmp = (2.0 / t_m) * (((l / k_m) / sin(k_m)) ^ 2.0); end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 9.5e+29], N[Power[N[(l * N[(N[(1.0 / k$95$m), $MachinePrecision] * N[(N[Sqrt[N[(2.0 / t$95$m), $MachinePrecision]], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[k$95$m, 2.3e+156], N[(N[(2.0 / N[(N[(k$95$m / t$95$m), $MachinePrecision] * N[(k$95$m / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[Power[t$95$m, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t$95$m / l), $MachinePrecision]), $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / t$95$m), $MachinePrecision] * N[Power[N[(N[(l / k$95$m), $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 9.5 \cdot 10^{+29}:\\
\;\;\;\;{\left(\ell \cdot \left(\frac{1}{k\_m} \cdot \frac{\sqrt{\frac{2}{t\_m}}}{k\_m}\right)\right)}^{2}\\
\mathbf{elif}\;k\_m \leq 2.3 \cdot 10^{+156}:\\
\;\;\;\;\frac{\frac{2}{\frac{k\_m}{t\_m} \cdot \frac{k\_m}{t\_m}}}{\left(\frac{{t\_m}^{2}}{\ell} \cdot \frac{t\_m}{\ell}\right) \cdot \left(\sin k\_m \cdot \tan k\_m\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{t\_m} \cdot {\left(\frac{\frac{\ell}{k\_m}}{\sin k\_m}\right)}^{2}\\
\end{array}
\end{array}
if k < 9.5000000000000003e29Initial program 35.6%
Simplified45.5%
add-sqr-sqrt30.6%
pow230.6%
Applied egg-rr32.6%
*-commutative32.6%
Simplified32.6%
Taylor expanded in k around 0 46.7%
associate-*l/46.7%
associate-/l*46.7%
Simplified46.7%
pow146.7%
associate-*r/46.7%
sqrt-prod46.8%
div-inv46.8%
Applied egg-rr46.8%
unpow146.8%
Simplified46.8%
*-un-lft-identity46.8%
unpow246.8%
times-frac47.7%
Applied egg-rr47.7%
if 9.5000000000000003e29 < k < 2.2999999999999999e156Initial program 34.6%
*-commutative34.6%
associate-/r*34.7%
Simplified53.9%
unpow353.9%
times-frac61.7%
pow261.7%
Applied egg-rr61.7%
unpow261.7%
Applied egg-rr61.7%
if 2.2999999999999999e156 < k Initial program 50.0%
Simplified60.0%
add-sqr-sqrt60.0%
pow260.0%
Applied egg-rr43.5%
*-commutative43.5%
Simplified43.5%
Taylor expanded in l around 0 43.1%
*-commutative43.1%
associate-/r*43.1%
*-commutative43.1%
associate-/l*43.1%
Simplified43.1%
Taylor expanded in k around 0 38.2%
unpow1/238.2%
rem-exp-log38.2%
exp-neg38.2%
exp-prod38.2%
distribute-lft-neg-out38.2%
distribute-rgt-neg-in38.2%
metadata-eval38.2%
exp-to-pow38.2%
Simplified38.2%
*-commutative38.2%
unpow-prod-down37.8%
associate-/l*37.8%
unpow-prod-down37.8%
pow237.8%
rem-square-sqrt37.8%
pow-pow75.5%
metadata-eval75.5%
inv-pow75.5%
Applied egg-rr75.5%
*-commutative75.5%
associate-*r*75.5%
associate-*l/75.5%
metadata-eval75.5%
Simplified75.5%
Final simplification52.4%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (pow (* l (* (/ 1.0 k_m) (/ (sqrt (/ 2.0 t_m)) k_m))) 2.0)))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * pow((l * ((1.0 / k_m) * (sqrt((2.0 / t_m)) / k_m))), 2.0);
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * ((1.0d0 / k_m) * (sqrt((2.0d0 / t_m)) / k_m))) ** 2.0d0)
end function
k_m = Math.abs(k);
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_m) {
return t_s * Math.pow((l * ((1.0 / k_m) * (Math.sqrt((2.0 / t_m)) / k_m))), 2.0);
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * math.pow((l * ((1.0 / k_m) * (math.sqrt((2.0 / t_m)) / k_m))), 2.0)
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * (Float64(l * Float64(Float64(1.0 / k_m) * Float64(sqrt(Float64(2.0 / t_m)) / k_m))) ^ 2.0)) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * ((1.0 / k_m) * (sqrt((2.0 / t_m)) / k_m))) ^ 2.0); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[Power[N[(l * N[(N[(1.0 / k$95$m), $MachinePrecision] * N[(N[Sqrt[N[(2.0 / t$95$m), $MachinePrecision]], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot {\left(\ell \cdot \left(\frac{1}{k\_m} \cdot \frac{\sqrt{\frac{2}{t\_m}}}{k\_m}\right)\right)}^{2}
\end{array}
Initial program 37.2%
Simplified48.9%
add-sqr-sqrt35.6%
pow235.6%
Applied egg-rr31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in k around 0 44.5%
associate-*l/44.5%
associate-/l*44.4%
Simplified44.4%
pow144.4%
associate-*r/44.5%
sqrt-prod44.5%
div-inv44.5%
Applied egg-rr44.5%
unpow144.5%
Simplified44.5%
*-un-lft-identity44.5%
unpow244.5%
times-frac45.2%
Applied egg-rr45.2%
Final simplification45.2%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (/ 2.0 t_m) (pow (/ (/ l k_m) (sin k_m)) 2.0))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((2.0 / t_m) * pow(((l / k_m) / sin(k_m)), 2.0));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((2.0d0 / t_m) * (((l / k_m) / sin(k_m)) ** 2.0d0))
end function
k_m = Math.abs(k);
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_m) {
return t_s * ((2.0 / t_m) * Math.pow(((l / k_m) / Math.sin(k_m)), 2.0));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((2.0 / t_m) * math.pow(((l / k_m) / math.sin(k_m)), 2.0))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(2.0 / t_m) * (Float64(Float64(l / k_m) / sin(k_m)) ^ 2.0))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((2.0 / t_m) * (((l / k_m) / sin(k_m)) ^ 2.0)); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[(N[(2.0 / t$95$m), $MachinePrecision] * N[Power[N[(N[(l / k$95$m), $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\frac{2}{t\_m} \cdot {\left(\frac{\frac{\ell}{k\_m}}{\sin k\_m}\right)}^{2}\right)
\end{array}
Initial program 37.2%
Simplified48.9%
add-sqr-sqrt35.6%
pow235.6%
Applied egg-rr31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in l around 0 52.1%
*-commutative52.1%
associate-/r*53.2%
*-commutative53.2%
associate-/l*53.3%
Simplified53.3%
Taylor expanded in k around 0 46.4%
unpow1/246.4%
rem-exp-log46.0%
exp-neg45.9%
exp-prod45.9%
distribute-lft-neg-out45.9%
distribute-rgt-neg-in45.9%
metadata-eval45.9%
exp-to-pow46.4%
Simplified46.4%
*-commutative46.4%
unpow-prod-down44.8%
associate-/l*44.8%
unpow-prod-down44.8%
pow244.8%
rem-square-sqrt44.8%
pow-pow78.4%
metadata-eval78.4%
inv-pow78.4%
Applied egg-rr78.4%
*-commutative78.4%
associate-*r*78.4%
associate-*l/78.4%
metadata-eval78.4%
Simplified78.4%
Final simplification78.4%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* 2.0 (/ (/ (pow l 2.0) (pow k_m 4.0)) t_m))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * (2.0 * ((pow(l, 2.0) / pow(k_m, 4.0)) / t_m));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * (2.0d0 * (((l ** 2.0d0) / (k_m ** 4.0d0)) / t_m))
end function
k_m = Math.abs(k);
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_m) {
return t_s * (2.0 * ((Math.pow(l, 2.0) / Math.pow(k_m, 4.0)) / t_m));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * (2.0 * ((math.pow(l, 2.0) / math.pow(k_m, 4.0)) / t_m))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(2.0 * Float64(Float64((l ^ 2.0) / (k_m ^ 4.0)) / t_m))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * (2.0 * (((l ^ 2.0) / (k_m ^ 4.0)) / t_m)); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(2 \cdot \frac{\frac{{\ell}^{2}}{{k\_m}^{4}}}{t\_m}\right)
\end{array}
Initial program 37.2%
Simplified48.9%
Taylor expanded in k around 0 63.3%
Taylor expanded in k around 0 63.3%
associate-/r*63.7%
Simplified63.7%
Final simplification63.7%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= k_m 6.5e+29)
(* (* l l) (fabs (/ -0.11666666666666667 t_m)))
(/ (* (pow l 2.0) -0.11666666666666667) t_m))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 6.5e+29) {
tmp = (l * l) * fabs((-0.11666666666666667 / t_m));
} else {
tmp = (pow(l, 2.0) * -0.11666666666666667) / t_m;
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 6.5d+29) then
tmp = (l * l) * abs(((-0.11666666666666667d0) / t_m))
else
tmp = ((l ** 2.0d0) * (-0.11666666666666667d0)) / t_m
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
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_m) {
double tmp;
if (k_m <= 6.5e+29) {
tmp = (l * l) * Math.abs((-0.11666666666666667 / t_m));
} else {
tmp = (Math.pow(l, 2.0) * -0.11666666666666667) / t_m;
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if k_m <= 6.5e+29: tmp = (l * l) * math.fabs((-0.11666666666666667 / t_m)) else: tmp = (math.pow(l, 2.0) * -0.11666666666666667) / t_m return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (k_m <= 6.5e+29) tmp = Float64(Float64(l * l) * abs(Float64(-0.11666666666666667 / t_m))); else tmp = Float64(Float64((l ^ 2.0) * -0.11666666666666667) / t_m); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if (k_m <= 6.5e+29) tmp = (l * l) * abs((-0.11666666666666667 / t_m)); else tmp = ((l ^ 2.0) * -0.11666666666666667) / t_m; end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 6.5e+29], N[(N[(l * l), $MachinePrecision] * N[Abs[N[(-0.11666666666666667 / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] * -0.11666666666666667), $MachinePrecision] / t$95$m), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 6.5 \cdot 10^{+29}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \left|\frac{-0.11666666666666667}{t\_m}\right|\\
\mathbf{else}:\\
\;\;\;\;\frac{{\ell}^{2} \cdot -0.11666666666666667}{t\_m}\\
\end{array}
\end{array}
if k < 6.49999999999999971e29Initial program 35.6%
Simplified45.5%
Taylor expanded in k around 0 51.2%
Taylor expanded in k around inf 14.2%
add-sqr-sqrt4.7%
sqrt-unprod25.9%
pow225.9%
Applied egg-rr25.9%
unpow225.9%
rem-sqrt-square28.1%
Simplified28.1%
if 6.49999999999999971e29 < k Initial program 42.9%
Simplified60.7%
Taylor expanded in k around 0 11.2%
Taylor expanded in k around inf 38.2%
*-commutative38.2%
associate-*l/38.2%
Simplified38.2%
Final simplification30.3%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ 2.0 (* t_m (pow k_m 4.0))))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / (t_m * pow(k_m, 4.0))));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * (2.0d0 / (t_m * (k_m ** 4.0d0))))
end function
k_m = Math.abs(k);
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_m) {
return t_s * ((l * l) * (2.0 / (t_m * Math.pow(k_m, 4.0))));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * (2.0 / (t_m * math.pow(k_m, 4.0))))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(2.0 / Float64(t_m * (k_m ^ 4.0))))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * (2.0 / (t_m * (k_m ^ 4.0)))); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(t$95$m * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{2}{t\_m \cdot {k\_m}^{4}}\right)
\end{array}
Initial program 37.2%
Simplified48.9%
Taylor expanded in k around 0 63.3%
Final simplification63.3%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (/ (* (pow l 2.0) -0.11666666666666667) t_m)))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((pow(l, 2.0) * -0.11666666666666667) / t_m);
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * (((l ** 2.0d0) * (-0.11666666666666667d0)) / t_m)
end function
k_m = Math.abs(k);
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_m) {
return t_s * ((Math.pow(l, 2.0) * -0.11666666666666667) / t_m);
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((math.pow(l, 2.0) * -0.11666666666666667) / t_m)
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64((l ^ 2.0) * -0.11666666666666667) / t_m)) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * (((l ^ 2.0) * -0.11666666666666667) / t_m); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[(N[(N[Power[l, 2.0], $MachinePrecision] * -0.11666666666666667), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \frac{{\ell}^{2} \cdot -0.11666666666666667}{t\_m}
\end{array}
Initial program 37.2%
Simplified48.9%
Taylor expanded in k around 0 42.4%
Taylor expanded in k around inf 19.5%
*-commutative19.5%
associate-*l/19.5%
Simplified19.5%
Final simplification19.5%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ -0.11666666666666667 t_m))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (-0.11666666666666667 / t_m));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * ((-0.11666666666666667d0) / t_m))
end function
k_m = Math.abs(k);
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_m) {
return t_s * ((l * l) * (-0.11666666666666667 / t_m));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * (-0.11666666666666667 / t_m))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(-0.11666666666666667 / t_m))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * (-0.11666666666666667 / t_m)); end
k_m = N[Abs[k], $MachinePrecision]
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$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(-0.11666666666666667 / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{-0.11666666666666667}{t\_m}\right)
\end{array}
Initial program 37.2%
Simplified48.9%
Taylor expanded in k around 0 42.4%
Taylor expanded in k around inf 19.5%
Final simplification19.5%
herbie shell --seed 2024073
(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))))