
(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 24 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}
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (cbrt (sqrt l_m))) (t_3 (cbrt (* (sin k_m) (tan k_m)))))
(*
t_s
(if (<= k_m 0.48)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(*
(/
(* t_m (/ (sqrt 2.0) k_m))
(pow (* (/ t_m (pow (* t_2 t_2) 2.0)) t_3) 2.0))
(/ (* (/ (/ (* (sqrt 2.0) t_m) k_m) t_m) (pow (cbrt l_m) 2.0)) t_3))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = cbrt(sqrt(l_m));
double t_3 = cbrt((sin(k_m) * tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * (sqrt(2.0) / k_m)) / pow(((t_m / pow((t_2 * t_2), 2.0)) * t_3), 2.0)) * (((((sqrt(2.0) * t_m) / k_m) / t_m) * pow(cbrt(l_m), 2.0)) / t_3);
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.cbrt(Math.sqrt(l_m));
double t_3 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * (Math.sqrt(2.0) / k_m)) / Math.pow(((t_m / Math.pow((t_2 * t_2), 2.0)) * t_3), 2.0)) * (((((Math.sqrt(2.0) * t_m) / k_m) / t_m) * Math.pow(Math.cbrt(l_m), 2.0)) / t_3);
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = cbrt(sqrt(l_m)) t_3 = cbrt(Float64(sin(k_m) * tan(k_m))) tmp = 0.0 if (k_m <= 0.48) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_m * Float64(sqrt(2.0) / k_m)) / (Float64(Float64(t_m / (Float64(t_2 * t_2) ^ 2.0)) * t_3) ^ 2.0)) * Float64(Float64(Float64(Float64(Float64(sqrt(2.0) * t_m) / k_m) / t_m) * (cbrt(l_m) ^ 2.0)) / t_3)); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[Sqrt[l$95$m], $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 0.48], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(t$95$m * N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision] / N[Power[N[(N[(t$95$m / N[Power[N[(t$95$2 * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * t$95$3), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] * t$95$m), $MachinePrecision] / k$95$m), $MachinePrecision] / t$95$m), $MachinePrecision] * N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \sqrt[3]{\sqrt{l\_m}}\\
t_3 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 0.48:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_m \cdot \frac{\sqrt{2}}{k\_m}}{{\left(\frac{t\_m}{{\left(t\_2 \cdot t\_2\right)}^{2}} \cdot t\_3\right)}^{2}} \cdot \frac{\frac{\frac{\sqrt{2} \cdot t\_m}{k\_m}}{t\_m} \cdot {\left(\sqrt[3]{l\_m}\right)}^{2}}{t\_3}\\
\end{array}
\end{array}
\end{array}
if k < 0.47999999999999998Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 0.47999999999999998 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
pow1/338.6%
add-sqr-sqrt38.6%
unpow-prod-down38.6%
Applied egg-rr38.6%
unpow1/338.8%
unpow1/339.3%
Simplified39.3%
associate-/r/39.4%
associate-*l/39.4%
Applied egg-rr39.4%
Final simplification45.8%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (cbrt (sqrt l_m)))
(t_3 (cbrt (* (sin k_m) (tan k_m))))
(t_4 (/ (sqrt 2.0) k_m)))
(*
t_s
(if (<= k_m 0.48)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(*
(/ (* t_m t_4) (pow (* (/ t_m (pow (* t_2 t_2) 2.0)) t_3) 2.0))
(/ (* t_4 (/ 1.0 (pow (cbrt l_m) -2.0))) t_3))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = cbrt(sqrt(l_m));
double t_3 = cbrt((sin(k_m) * tan(k_m)));
double t_4 = sqrt(2.0) / k_m;
double tmp;
if (k_m <= 0.48) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * t_4) / pow(((t_m / pow((t_2 * t_2), 2.0)) * t_3), 2.0)) * ((t_4 * (1.0 / pow(cbrt(l_m), -2.0))) / t_3);
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.cbrt(Math.sqrt(l_m));
double t_3 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double t_4 = Math.sqrt(2.0) / k_m;
double tmp;
if (k_m <= 0.48) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * t_4) / Math.pow(((t_m / Math.pow((t_2 * t_2), 2.0)) * t_3), 2.0)) * ((t_4 * (1.0 / Math.pow(Math.cbrt(l_m), -2.0))) / t_3);
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = cbrt(sqrt(l_m)) t_3 = cbrt(Float64(sin(k_m) * tan(k_m))) t_4 = Float64(sqrt(2.0) / k_m) tmp = 0.0 if (k_m <= 0.48) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_m * t_4) / (Float64(Float64(t_m / (Float64(t_2 * t_2) ^ 2.0)) * t_3) ^ 2.0)) * Float64(Float64(t_4 * Float64(1.0 / (cbrt(l_m) ^ -2.0))) / t_3)); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[Sqrt[l$95$m], $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 0.48], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(t$95$m * t$95$4), $MachinePrecision] / N[Power[N[(N[(t$95$m / N[Power[N[(t$95$2 * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * t$95$3), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$4 * N[(1.0 / N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \sqrt[3]{\sqrt{l\_m}}\\
t_3 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t_4 := \frac{\sqrt{2}}{k\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 0.48:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_m \cdot t\_4}{{\left(\frac{t\_m}{{\left(t\_2 \cdot t\_2\right)}^{2}} \cdot t\_3\right)}^{2}} \cdot \frac{t\_4 \cdot \frac{1}{{\left(\sqrt[3]{l\_m}\right)}^{-2}}}{t\_3}\\
\end{array}
\end{array}
\end{array}
if k < 0.47999999999999998Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 0.47999999999999998 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
pow1/338.6%
add-sqr-sqrt38.6%
unpow-prod-down38.6%
Applied egg-rr38.6%
unpow1/338.8%
unpow1/339.3%
Simplified39.3%
associate-/l*39.4%
div-inv39.4%
pow-flip39.4%
metadata-eval39.4%
Applied egg-rr39.4%
associate-/r*39.4%
*-inverses39.4%
Simplified39.4%
Final simplification45.8%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (cbrt (* (sin k_m) (tan k_m)))))
(*
t_s
(if (<= k_m 0.48)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(*
(/
(* t_m (/ (sqrt 2.0) k_m))
(pow (* t_2 (/ t_m (pow (cbrt l_m) 2.0))) 2.0))
(pow
(cbrt
(/ (/ (* (sqrt 2.0) t_m) k_m) (* t_2 (* t_m (pow (cbrt l_m) -2.0)))))
3.0))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = cbrt((sin(k_m) * tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * (sqrt(2.0) / k_m)) / pow((t_2 * (t_m / pow(cbrt(l_m), 2.0))), 2.0)) * pow(cbrt((((sqrt(2.0) * t_m) / k_m) / (t_2 * (t_m * pow(cbrt(l_m), -2.0))))), 3.0);
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * (Math.sqrt(2.0) / k_m)) / Math.pow((t_2 * (t_m / Math.pow(Math.cbrt(l_m), 2.0))), 2.0)) * Math.pow(Math.cbrt((((Math.sqrt(2.0) * t_m) / k_m) / (t_2 * (t_m * Math.pow(Math.cbrt(l_m), -2.0))))), 3.0);
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = cbrt(Float64(sin(k_m) * tan(k_m))) tmp = 0.0 if (k_m <= 0.48) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_m * Float64(sqrt(2.0) / k_m)) / (Float64(t_2 * Float64(t_m / (cbrt(l_m) ^ 2.0))) ^ 2.0)) * (cbrt(Float64(Float64(Float64(sqrt(2.0) * t_m) / k_m) / Float64(t_2 * Float64(t_m * (cbrt(l_m) ^ -2.0))))) ^ 3.0)); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 0.48], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(t$95$m * N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision] / N[Power[N[(t$95$2 * N[(t$95$m / N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Power[N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] * t$95$m), $MachinePrecision] / k$95$m), $MachinePrecision] / N[(t$95$2 * N[(t$95$m * N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 0.48:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_m \cdot \frac{\sqrt{2}}{k\_m}}{{\left(t\_2 \cdot \frac{t\_m}{{\left(\sqrt[3]{l\_m}\right)}^{2}}\right)}^{2}} \cdot {\left(\sqrt[3]{\frac{\frac{\sqrt{2} \cdot t\_m}{k\_m}}{t\_2 \cdot \left(t\_m \cdot {\left(\sqrt[3]{l\_m}\right)}^{-2}\right)}}\right)}^{3}\\
\end{array}
\end{array}
\end{array}
if k < 0.47999999999999998Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 0.47999999999999998 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
add-cube-cbrt77.2%
pow377.2%
associate-/l/77.2%
associate-*l/77.2%
*-commutative77.2%
div-inv77.2%
pow-flip77.3%
metadata-eval77.3%
Applied egg-rr77.3%
Final simplification56.4%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (pow (cbrt l_m) 2.0)) (t_3 (cbrt (* (sin k_m) (tan k_m)))))
(*
t_s
(if (<= k_m 0.48)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(*
(/ (* t_m (/ (sqrt 2.0) k_m)) (pow (* t_3 (/ t_m t_2)) 2.0))
(/ (pow (cbrt (* (/ (/ (* (sqrt 2.0) t_m) k_m) t_m) t_2)) 3.0) t_3))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = pow(cbrt(l_m), 2.0);
double t_3 = cbrt((sin(k_m) * tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * (sqrt(2.0) / k_m)) / pow((t_3 * (t_m / t_2)), 2.0)) * (pow(cbrt(((((sqrt(2.0) * t_m) / k_m) / t_m) * t_2)), 3.0) / t_3);
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.pow(Math.cbrt(l_m), 2.0);
double t_3 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_m * (Math.sqrt(2.0) / k_m)) / Math.pow((t_3 * (t_m / t_2)), 2.0)) * (Math.pow(Math.cbrt(((((Math.sqrt(2.0) * t_m) / k_m) / t_m) * t_2)), 3.0) / t_3);
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = cbrt(l_m) ^ 2.0 t_3 = cbrt(Float64(sin(k_m) * tan(k_m))) tmp = 0.0 if (k_m <= 0.48) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_m * Float64(sqrt(2.0) / k_m)) / (Float64(t_3 * Float64(t_m / t_2)) ^ 2.0)) * Float64((cbrt(Float64(Float64(Float64(Float64(sqrt(2.0) * t_m) / k_m) / t_m) * t_2)) ^ 3.0) / t_3)); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]}, Block[{t$95$3 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 0.48], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(t$95$m * N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision] / N[Power[N[(t$95$3 * N[(t$95$m / t$95$2), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[Power[N[(N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] * t$95$m), $MachinePrecision] / k$95$m), $MachinePrecision] / t$95$m), $MachinePrecision] * t$95$2), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := {\left(\sqrt[3]{l\_m}\right)}^{2}\\
t_3 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 0.48:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_m \cdot \frac{\sqrt{2}}{k\_m}}{{\left(t\_3 \cdot \frac{t\_m}{t\_2}\right)}^{2}} \cdot \frac{{\left(\sqrt[3]{\frac{\frac{\sqrt{2} \cdot t\_m}{k\_m}}{t\_m} \cdot t\_2}\right)}^{3}}{t\_3}\\
\end{array}
\end{array}
\end{array}
if k < 0.47999999999999998Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 0.47999999999999998 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
add-cube-cbrt77.3%
pow377.3%
associate-/r/77.3%
associate-*l/77.3%
Applied egg-rr77.3%
Final simplification56.4%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (* t_m (/ (sqrt 2.0) k_m))) (t_3 (cbrt (* (sin k_m) (tan k_m)))))
(*
t_s
(if (<= k_m 0.48)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(*
(/ t_2 (pow (* t_3 (/ t_m (pow (cbrt l_m) 2.0))) 2.0))
(/ (/ t_2 (/ t_m (pow (pow (cbrt (cbrt l_m)) 3.0) 2.0))) t_3))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = t_m * (sqrt(2.0) / k_m);
double t_3 = cbrt((sin(k_m) * tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = (t_2 / pow((t_3 * (t_m / pow(cbrt(l_m), 2.0))), 2.0)) * ((t_2 / (t_m / pow(pow(cbrt(cbrt(l_m)), 3.0), 2.0))) / t_3);
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = t_m * (Math.sqrt(2.0) / k_m);
double t_3 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double tmp;
if (k_m <= 0.48) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = (t_2 / Math.pow((t_3 * (t_m / Math.pow(Math.cbrt(l_m), 2.0))), 2.0)) * ((t_2 / (t_m / Math.pow(Math.pow(Math.cbrt(Math.cbrt(l_m)), 3.0), 2.0))) / t_3);
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = Float64(t_m * Float64(sqrt(2.0) / k_m)) t_3 = cbrt(Float64(sin(k_m) * tan(k_m))) tmp = 0.0 if (k_m <= 0.48) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(t_2 / (Float64(t_3 * Float64(t_m / (cbrt(l_m) ^ 2.0))) ^ 2.0)) * Float64(Float64(t_2 / Float64(t_m / ((cbrt(cbrt(l_m)) ^ 3.0) ^ 2.0))) / t_3)); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[(t$95$m * N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 0.48], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(t$95$2 / N[Power[N[(t$95$3 * N[(t$95$m / N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$2 / N[(t$95$m / N[Power[N[Power[N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := t\_m \cdot \frac{\sqrt{2}}{k\_m}\\
t_3 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 0.48:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_2}{{\left(t\_3 \cdot \frac{t\_m}{{\left(\sqrt[3]{l\_m}\right)}^{2}}\right)}^{2}} \cdot \frac{\frac{t\_2}{\frac{t\_m}{{\left({\left(\sqrt[3]{\sqrt[3]{l\_m}}\right)}^{3}\right)}^{2}}}}{t\_3}\\
\end{array}
\end{array}
\end{array}
if k < 0.47999999999999998Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 0.47999999999999998 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
add-cube-cbrt77.2%
pow377.2%
Applied egg-rr77.2%
Final simplification56.3%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (/ t_m (pow (cbrt l_m) 2.0)))
(t_3 (* t_m (/ (sqrt 2.0) k_m)))
(t_4 (cbrt (* (sin k_m) (tan k_m)))))
(*
t_s
(if (<= k_m 5.4e-6)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(* (/ t_3 (pow (* t_4 t_2) 2.0)) (/ (/ t_3 t_2) t_4))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = t_m / pow(cbrt(l_m), 2.0);
double t_3 = t_m * (sqrt(2.0) / k_m);
double t_4 = cbrt((sin(k_m) * tan(k_m)));
double tmp;
if (k_m <= 5.4e-6) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = (t_3 / pow((t_4 * t_2), 2.0)) * ((t_3 / t_2) / t_4);
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = t_m / Math.pow(Math.cbrt(l_m), 2.0);
double t_3 = t_m * (Math.sqrt(2.0) / k_m);
double t_4 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double tmp;
if (k_m <= 5.4e-6) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = (t_3 / Math.pow((t_4 * t_2), 2.0)) * ((t_3 / t_2) / t_4);
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = Float64(t_m / (cbrt(l_m) ^ 2.0)) t_3 = Float64(t_m * Float64(sqrt(2.0) / k_m)) t_4 = cbrt(Float64(sin(k_m) * tan(k_m))) tmp = 0.0 if (k_m <= 5.4e-6) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(t_3 / (Float64(t_4 * t_2) ^ 2.0)) * Float64(Float64(t_3 / t_2) / t_4)); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[(t$95$m / N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$m * N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 5.4e-6], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(t$95$3 / N[Power[N[(t$95$4 * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$3 / t$95$2), $MachinePrecision] / t$95$4), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \frac{t\_m}{{\left(\sqrt[3]{l\_m}\right)}^{2}}\\
t_3 := t\_m \cdot \frac{\sqrt{2}}{k\_m}\\
t_4 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 5.4 \cdot 10^{-6}:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_3}{{\left(t\_4 \cdot t\_2\right)}^{2}} \cdot \frac{\frac{t\_3}{t\_2}}{t\_4}\\
\end{array}
\end{array}
\end{array}
if k < 5.39999999999999997e-6Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 5.39999999999999997e-6 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
Final simplification56.4%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (cbrt (* (sin k_m) (tan k_m)))) (t_3 (/ (sqrt 2.0) k_m)))
(*
t_s
(if (<= k_m 5.4e-6)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(*
(/ (* t_3 (/ 1.0 (pow (cbrt l_m) -2.0))) t_2)
(/ (* t_m t_3) (pow (* t_2 (/ t_m (pow (cbrt l_m) 2.0))) 2.0)))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = cbrt((sin(k_m) * tan(k_m)));
double t_3 = sqrt(2.0) / k_m;
double tmp;
if (k_m <= 5.4e-6) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (1.0 / pow(cbrt(l_m), -2.0))) / t_2) * ((t_m * t_3) / pow((t_2 * (t_m / pow(cbrt(l_m), 2.0))), 2.0));
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double t_3 = Math.sqrt(2.0) / k_m;
double tmp;
if (k_m <= 5.4e-6) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (1.0 / Math.pow(Math.cbrt(l_m), -2.0))) / t_2) * ((t_m * t_3) / Math.pow((t_2 * (t_m / Math.pow(Math.cbrt(l_m), 2.0))), 2.0));
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = cbrt(Float64(sin(k_m) * tan(k_m))) t_3 = Float64(sqrt(2.0) / k_m) tmp = 0.0 if (k_m <= 5.4e-6) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_3 * Float64(1.0 / (cbrt(l_m) ^ -2.0))) / t_2) * Float64(Float64(t_m * t_3) / (Float64(t_2 * Float64(t_m / (cbrt(l_m) ^ 2.0))) ^ 2.0))); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 5.4e-6], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(t$95$3 * N[(1.0 / N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] * N[(N[(t$95$m * t$95$3), $MachinePrecision] / N[Power[N[(t$95$2 * N[(t$95$m / N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t_3 := \frac{\sqrt{2}}{k\_m}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 5.4 \cdot 10^{-6}:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_3 \cdot \frac{1}{{\left(\sqrt[3]{l\_m}\right)}^{-2}}}{t\_2} \cdot \frac{t\_m \cdot t\_3}{{\left(t\_2 \cdot \frac{t\_m}{{\left(\sqrt[3]{l\_m}\right)}^{2}}\right)}^{2}}\\
\end{array}
\end{array}
\end{array}
if k < 5.39999999999999997e-6Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 5.39999999999999997e-6 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
associate-/l*39.4%
div-inv39.4%
pow-flip39.4%
metadata-eval39.4%
Applied egg-rr77.3%
associate-/r*39.4%
*-inverses39.4%
Simplified77.3%
Final simplification56.4%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (cbrt (* (sin k_m) (tan k_m)))) (t_3 (pow (cbrt l_m) 2.0)))
(*
t_s
(if (<= k_m 5.4e-6)
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(*
(/ (* (sqrt 2.0) t_m) k_m)
(/
(* (/ (sqrt 2.0) k_m) t_3)
(* t_2 (pow (* t_2 (/ t_m t_3)) 2.0))))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = cbrt((sin(k_m) * tan(k_m)));
double t_3 = pow(cbrt(l_m), 2.0);
double tmp;
if (k_m <= 5.4e-6) {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((sqrt(2.0) * t_m) / k_m) * (((sqrt(2.0) / k_m) * t_3) / (t_2 * pow((t_2 * (t_m / t_3)), 2.0)));
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double t_3 = Math.pow(Math.cbrt(l_m), 2.0);
double tmp;
if (k_m <= 5.4e-6) {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((Math.sqrt(2.0) * t_m) / k_m) * (((Math.sqrt(2.0) / k_m) * t_3) / (t_2 * Math.pow((t_2 * (t_m / t_3)), 2.0)));
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = cbrt(Float64(sin(k_m) * tan(k_m))) t_3 = cbrt(l_m) ^ 2.0 tmp = 0.0 if (k_m <= 5.4e-6) tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(sqrt(2.0) * t_m) / k_m) * Float64(Float64(Float64(sqrt(2.0) / k_m) * t_3) / Float64(t_2 * (Float64(t_2 * Float64(t_m / t_3)) ^ 2.0)))); end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$3 = N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 5.4e-6], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] * t$95$m), $MachinePrecision] / k$95$m), $MachinePrecision] * N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision] * t$95$3), $MachinePrecision] / N[(t$95$2 * N[Power[N[(t$95$2 * N[(t$95$m / t$95$3), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \sqrt[3]{\sin k\_m \cdot \tan k\_m}\\
t_3 := {\left(\sqrt[3]{l\_m}\right)}^{2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 5.4 \cdot 10^{-6}:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2} \cdot t\_m}{k\_m} \cdot \frac{\frac{\sqrt{2}}{k\_m} \cdot t\_3}{t\_2 \cdot {\left(t\_2 \cdot \frac{t\_m}{t\_3}\right)}^{2}}\\
\end{array}
\end{array}
\end{array}
if k < 5.39999999999999997e-6Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in l around 0 46.3%
times-frac48.3%
Simplified48.3%
if 5.39999999999999997e-6 < k Initial program 32.7%
Simplified32.7%
Applied egg-rr75.8%
associate-/r/75.8%
associate-/r*75.8%
associate-/r/77.2%
Simplified77.2%
pow1/338.6%
add-sqr-sqrt38.6%
unpow-prod-down38.6%
Applied egg-rr38.6%
unpow1/338.8%
unpow1/339.3%
Simplified39.3%
associate-/l*39.4%
div-inv39.4%
pow-flip39.4%
metadata-eval39.4%
Applied egg-rr39.4%
associate-/r*39.4%
*-inverses39.4%
Simplified39.4%
frac-times36.7%
pow-flip36.7%
metadata-eval36.7%
Applied egg-rr70.6%
associate-/l*77.2%
associate-*l/77.2%
*-commutative77.2%
Simplified77.2%
Final simplification56.4%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (pow (/ k_m t_m) 2.0)))
(*
t_s
(if (<=
(/
2.0
(*
(* (tan k_m) (* (sin k_m) (/ (pow t_m 3.0) (* l_m l_m))))
(+ (+ 1.0 t_2) -1.0)))
0.0)
(/
2.0
(pow
(* (/ t_m (pow (cbrt l_m) 2.0)) (cbrt (* (sin k_m) (* (tan k_m) t_2))))
3.0))
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = pow((k_m / t_m), 2.0);
double tmp;
if ((2.0 / ((tan(k_m) * (sin(k_m) * (pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) {
tmp = 2.0 / pow(((t_m / pow(cbrt(l_m), 2.0)) * cbrt((sin(k_m) * (tan(k_m) * t_2)))), 3.0);
} else {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
}
return t_s * tmp;
}
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.pow((k_m / t_m), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k_m) * (Math.sin(k_m) * (Math.pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) {
tmp = 2.0 / Math.pow(((t_m / Math.pow(Math.cbrt(l_m), 2.0)) * Math.cbrt((Math.sin(k_m) * (Math.tan(k_m) * t_2)))), 3.0);
} else {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
}
return t_s * tmp;
}
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = Float64(k_m / t_m) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k_m) * Float64(sin(k_m) * Float64((t_m ^ 3.0) / Float64(l_m * l_m)))) * Float64(Float64(1.0 + t_2) + -1.0))) <= 0.0) tmp = Float64(2.0 / (Float64(Float64(t_m / (cbrt(l_m) ^ 2.0)) * cbrt(Float64(sin(k_m) * Float64(tan(k_m) * t_2)))) ^ 3.0)); else tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; end return Float64(t_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[(k$95$m / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(2.0 / N[(N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + t$95$2), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0], N[(2.0 / N[Power[N[(N[(t$95$m / N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Tan[k$95$m], $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := {\left(\frac{k\_m}{t\_m}\right)}^{2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{2}{\left(\tan k\_m \cdot \left(\sin k\_m \cdot \frac{{t\_m}^{3}}{l\_m \cdot l\_m}\right)\right) \cdot \left(\left(1 + t\_2\right) + -1\right)} \leq 0:\\
\;\;\;\;\frac{2}{{\left(\frac{t\_m}{{\left(\sqrt[3]{l\_m}\right)}^{2}} \cdot \sqrt[3]{\sin k\_m \cdot \left(\tan k\_m \cdot t\_2\right)}\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\end{array}
\end{array}
\end{array}
if (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64)))) < 0.0Initial program 87.7%
Simplified87.8%
add-cube-cbrt87.7%
pow387.7%
Applied egg-rr98.1%
if 0.0 < (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64)))) Initial program 14.4%
Simplified21.2%
add-sqr-sqrt19.0%
pow219.0%
Applied egg-rr25.1%
associate-*r/25.0%
*-commutative25.0%
times-frac25.6%
Simplified25.6%
Taylor expanded in l around 0 55.6%
times-frac57.7%
Simplified57.7%
Final simplification69.8%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (pow (/ k_m t_m) 2.0)))
(*
t_s
(if (<=
(/
2.0
(*
(* (tan k_m) (* (sin k_m) (/ (pow t_m 3.0) (* l_m l_m))))
(+ (+ 1.0 t_2) -1.0)))
0.0)
(/
2.0
(*
(* (* (sin k_m) (tan k_m)) (* (/ (pow t_m 2.0) l_m) (/ t_m l_m)))
(+ 1.0 (+ t_2 -1.0))))
(pow
(* (* (/ l_m k_m) (/ (sqrt 2.0) (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = pow((k_m / t_m), 2.0);
double tmp;
if ((2.0 / ((tan(k_m) * (sin(k_m) * (pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) {
tmp = 2.0 / (((sin(k_m) * tan(k_m)) * ((pow(t_m, 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0)));
} else {
tmp = pow((((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: t_2
real(8) :: tmp
t_2 = (k_m / t_m) ** 2.0d0
if ((2.0d0 / ((tan(k_m) * (sin(k_m) * ((t_m ** 3.0d0) / (l_m * l_m)))) * ((1.0d0 + t_2) + (-1.0d0)))) <= 0.0d0) then
tmp = 2.0d0 / (((sin(k_m) * tan(k_m)) * (((t_m ** 2.0d0) / l_m) * (t_m / l_m))) * (1.0d0 + (t_2 + (-1.0d0))))
else
tmp = (((l_m / k_m) * (sqrt(2.0d0) / sin(k_m))) * sqrt((cos(k_m) / t_m))) ** 2.0d0
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.pow((k_m / t_m), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k_m) * (Math.sin(k_m) * (Math.pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) {
tmp = 2.0 / (((Math.sin(k_m) * Math.tan(k_m)) * ((Math.pow(t_m, 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0)));
} else {
tmp = Math.pow((((l_m / k_m) * (Math.sqrt(2.0) / Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): t_2 = math.pow((k_m / t_m), 2.0) tmp = 0 if (2.0 / ((math.tan(k_m) * (math.sin(k_m) * (math.pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0: tmp = 2.0 / (((math.sin(k_m) * math.tan(k_m)) * ((math.pow(t_m, 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0))) else: tmp = math.pow((((l_m / k_m) * (math.sqrt(2.0) / math.sin(k_m))) * math.sqrt((math.cos(k_m) / t_m))), 2.0) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = Float64(k_m / t_m) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k_m) * Float64(sin(k_m) * Float64((t_m ^ 3.0) / Float64(l_m * l_m)))) * Float64(Float64(1.0 + t_2) + -1.0))) <= 0.0) tmp = Float64(2.0 / Float64(Float64(Float64(sin(k_m) * tan(k_m)) * Float64(Float64((t_m ^ 2.0) / l_m) * Float64(t_m / l_m))) * Float64(1.0 + Float64(t_2 + -1.0)))); else tmp = Float64(Float64(Float64(l_m / k_m) * Float64(sqrt(2.0) / sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) t_2 = (k_m / t_m) ^ 2.0; tmp = 0.0; if ((2.0 / ((tan(k_m) * (sin(k_m) * ((t_m ^ 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) tmp = 2.0 / (((sin(k_m) * tan(k_m)) * (((t_m ^ 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0))); else tmp = (((l_m / k_m) * (sqrt(2.0) / sin(k_m))) * sqrt((cos(k_m) / t_m))) ^ 2.0; end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[(k$95$m / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(2.0 / N[(N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + t$95$2), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0], N[(2.0 / N[(N[(N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t$95$m, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision] * N[(t$95$m / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(t$95$2 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(N[(l$95$m / k$95$m), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[Sin[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := {\left(\frac{k\_m}{t\_m}\right)}^{2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{2}{\left(\tan k\_m \cdot \left(\sin k\_m \cdot \frac{{t\_m}^{3}}{l\_m \cdot l\_m}\right)\right) \cdot \left(\left(1 + t\_2\right) + -1\right)} \leq 0:\\
\;\;\;\;\frac{2}{\left(\left(\sin k\_m \cdot \tan k\_m\right) \cdot \left(\frac{{t\_m}^{2}}{l\_m} \cdot \frac{t\_m}{l\_m}\right)\right) \cdot \left(1 + \left(t\_2 + -1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(\left(\frac{l\_m}{k\_m} \cdot \frac{\sqrt{2}}{\sin k\_m}\right) \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\end{array}
\end{array}
\end{array}
if (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64)))) < 0.0Initial program 87.7%
Simplified87.8%
unpow387.8%
times-frac96.1%
pow296.1%
Applied egg-rr96.1%
if 0.0 < (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64)))) Initial program 14.4%
Simplified21.2%
add-sqr-sqrt19.0%
pow219.0%
Applied egg-rr25.1%
associate-*r/25.0%
*-commutative25.0%
times-frac25.6%
Simplified25.6%
Taylor expanded in l around 0 55.6%
times-frac57.7%
Simplified57.7%
Final simplification69.2%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(let* ((t_2 (pow (/ k_m t_m) 2.0)))
(*
t_s
(if (<=
(/
2.0
(*
(* (tan k_m) (* (sin k_m) (/ (pow t_m 3.0) (* l_m l_m))))
(+ (+ 1.0 t_2) -1.0)))
0.0)
(/
2.0
(*
(* (* (sin k_m) (tan k_m)) (* (/ (pow t_m 2.0) l_m) (/ t_m l_m)))
(+ 1.0 (+ t_2 -1.0))))
(pow
(* (sqrt (/ (cos k_m) t_m)) (* l_m (/ (sqrt 2.0) (* k_m (sin k_m)))))
2.0)))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double t_2 = pow((k_m / t_m), 2.0);
double tmp;
if ((2.0 / ((tan(k_m) * (sin(k_m) * (pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) {
tmp = 2.0 / (((sin(k_m) * tan(k_m)) * ((pow(t_m, 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0)));
} else {
tmp = pow((sqrt((cos(k_m) / t_m)) * (l_m * (sqrt(2.0) / (k_m * sin(k_m))))), 2.0);
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: t_2
real(8) :: tmp
t_2 = (k_m / t_m) ** 2.0d0
if ((2.0d0 / ((tan(k_m) * (sin(k_m) * ((t_m ** 3.0d0) / (l_m * l_m)))) * ((1.0d0 + t_2) + (-1.0d0)))) <= 0.0d0) then
tmp = 2.0d0 / (((sin(k_m) * tan(k_m)) * (((t_m ** 2.0d0) / l_m) * (t_m / l_m))) * (1.0d0 + (t_2 + (-1.0d0))))
else
tmp = (sqrt((cos(k_m) / t_m)) * (l_m * (sqrt(2.0d0) / (k_m * sin(k_m))))) ** 2.0d0
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double t_2 = Math.pow((k_m / t_m), 2.0);
double tmp;
if ((2.0 / ((Math.tan(k_m) * (Math.sin(k_m) * (Math.pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) {
tmp = 2.0 / (((Math.sin(k_m) * Math.tan(k_m)) * ((Math.pow(t_m, 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0)));
} else {
tmp = Math.pow((Math.sqrt((Math.cos(k_m) / t_m)) * (l_m * (Math.sqrt(2.0) / (k_m * Math.sin(k_m))))), 2.0);
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): t_2 = math.pow((k_m / t_m), 2.0) tmp = 0 if (2.0 / ((math.tan(k_m) * (math.sin(k_m) * (math.pow(t_m, 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0: tmp = 2.0 / (((math.sin(k_m) * math.tan(k_m)) * ((math.pow(t_m, 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0))) else: tmp = math.pow((math.sqrt((math.cos(k_m) / t_m)) * (l_m * (math.sqrt(2.0) / (k_m * math.sin(k_m))))), 2.0) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) t_2 = Float64(k_m / t_m) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(tan(k_m) * Float64(sin(k_m) * Float64((t_m ^ 3.0) / Float64(l_m * l_m)))) * Float64(Float64(1.0 + t_2) + -1.0))) <= 0.0) tmp = Float64(2.0 / Float64(Float64(Float64(sin(k_m) * tan(k_m)) * Float64(Float64((t_m ^ 2.0) / l_m) * Float64(t_m / l_m))) * Float64(1.0 + Float64(t_2 + -1.0)))); else tmp = Float64(sqrt(Float64(cos(k_m) / t_m)) * Float64(l_m * Float64(sqrt(2.0) / Float64(k_m * sin(k_m))))) ^ 2.0; end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) t_2 = (k_m / t_m) ^ 2.0; tmp = 0.0; if ((2.0 / ((tan(k_m) * (sin(k_m) * ((t_m ^ 3.0) / (l_m * l_m)))) * ((1.0 + t_2) + -1.0))) <= 0.0) tmp = 2.0 / (((sin(k_m) * tan(k_m)) * (((t_m ^ 2.0) / l_m) * (t_m / l_m))) * (1.0 + (t_2 + -1.0))); else tmp = (sqrt((cos(k_m) / t_m)) * (l_m * (sqrt(2.0) / (k_m * sin(k_m))))) ^ 2.0; end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := Block[{t$95$2 = N[Power[N[(k$95$m / t$95$m), $MachinePrecision], 2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(2.0 / N[(N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(l$95$m * l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + t$95$2), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0], N[(2.0 / N[(N[(N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t$95$m, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision] * N[(t$95$m / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(t$95$2 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[Sqrt[N[(N[Cos[k$95$m], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision] * N[(l$95$m * 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}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := {\left(\frac{k\_m}{t\_m}\right)}^{2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{2}{\left(\tan k\_m \cdot \left(\sin k\_m \cdot \frac{{t\_m}^{3}}{l\_m \cdot l\_m}\right)\right) \cdot \left(\left(1 + t\_2\right) + -1\right)} \leq 0:\\
\;\;\;\;\frac{2}{\left(\left(\sin k\_m \cdot \tan k\_m\right) \cdot \left(\frac{{t\_m}^{2}}{l\_m} \cdot \frac{t\_m}{l\_m}\right)\right) \cdot \left(1 + \left(t\_2 + -1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(\sqrt{\frac{\cos k\_m}{t\_m}} \cdot \left(l\_m \cdot \frac{\sqrt{2}}{k\_m \cdot \sin k\_m}\right)\right)}^{2}\\
\end{array}
\end{array}
\end{array}
if (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64)))) < 0.0Initial program 87.7%
Simplified87.8%
unpow387.8%
times-frac96.1%
pow296.1%
Applied egg-rr96.1%
if 0.0 < (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t #s(literal 3 binary64)) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (-.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 k t) #s(literal 2 binary64))) #s(literal 1 binary64)))) Initial program 14.4%
Simplified21.2%
add-sqr-sqrt19.0%
pow219.0%
Applied egg-rr25.1%
associate-*r/25.0%
*-commutative25.0%
times-frac25.6%
Simplified25.6%
Taylor expanded in l around 0 55.6%
associate-/l*55.1%
Simplified55.1%
Final simplification67.5%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(*
t_s
(if (<= k_m 9.6e-5)
(pow (* (/ (* l_m (sqrt 2.0)) (pow k_m 2.0)) (sqrt (/ 1.0 t_m))) 2.0)
(*
(* l_m l_m)
(/ (/ 2.0 (pow k_m 2.0)) (* t_m (/ (pow (sin k_m) 2.0) (cos k_m))))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (k_m <= 9.6e-5) {
tmp = pow((((l_m * sqrt(2.0)) / pow(k_m, 2.0)) * sqrt((1.0 / t_m))), 2.0);
} else {
tmp = (l_m * l_m) * ((2.0 / pow(k_m, 2.0)) / (t_m * (pow(sin(k_m), 2.0) / cos(k_m))));
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 9.6d-5) then
tmp = (((l_m * sqrt(2.0d0)) / (k_m ** 2.0d0)) * sqrt((1.0d0 / t_m))) ** 2.0d0
else
tmp = (l_m * l_m) * ((2.0d0 / (k_m ** 2.0d0)) / (t_m * ((sin(k_m) ** 2.0d0) / cos(k_m))))
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (k_m <= 9.6e-5) {
tmp = Math.pow((((l_m * Math.sqrt(2.0)) / Math.pow(k_m, 2.0)) * Math.sqrt((1.0 / t_m))), 2.0);
} else {
tmp = (l_m * l_m) * ((2.0 / Math.pow(k_m, 2.0)) / (t_m * (Math.pow(Math.sin(k_m), 2.0) / Math.cos(k_m))));
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if k_m <= 9.6e-5: tmp = math.pow((((l_m * math.sqrt(2.0)) / math.pow(k_m, 2.0)) * math.sqrt((1.0 / t_m))), 2.0) else: tmp = (l_m * l_m) * ((2.0 / math.pow(k_m, 2.0)) / (t_m * (math.pow(math.sin(k_m), 2.0) / math.cos(k_m)))) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (k_m <= 9.6e-5) tmp = Float64(Float64(Float64(l_m * sqrt(2.0)) / (k_m ^ 2.0)) * sqrt(Float64(1.0 / t_m))) ^ 2.0; else tmp = Float64(Float64(l_m * l_m) * Float64(Float64(2.0 / (k_m ^ 2.0)) / Float64(t_m * Float64((sin(k_m) ^ 2.0) / cos(k_m))))); end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (k_m <= 9.6e-5) tmp = (((l_m * sqrt(2.0)) / (k_m ^ 2.0)) * sqrt((1.0 / t_m))) ^ 2.0; else tmp = (l_m * l_m) * ((2.0 / (k_m ^ 2.0)) / (t_m * ((sin(k_m) ^ 2.0) / cos(k_m)))); end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 9.6e-5], N[Power[N[(N[(N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(N[(2.0 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$m * N[(N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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.6 \cdot 10^{-5}:\\
\;\;\;\;{\left(\frac{l\_m \cdot \sqrt{2}}{{k\_m}^{2}} \cdot \sqrt{\frac{1}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{\frac{2}{{k\_m}^{2}}}{t\_m \cdot \frac{{\sin k\_m}^{2}}{\cos k\_m}}\\
\end{array}
\end{array}
if k < 9.6000000000000002e-5Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in k around 0 37.0%
if 9.6000000000000002e-5 < k Initial program 32.7%
Simplified38.5%
Taylor expanded in t around 0 63.2%
associate-/l*63.2%
Simplified63.2%
*-un-lft-identity63.2%
associate-/r*63.5%
associate-/l*63.4%
Applied egg-rr63.4%
Final simplification44.3%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(*
t_s
(if (<= k_m 1.25e-5)
(pow (* (/ (* l_m (sqrt 2.0)) (pow k_m 2.0)) (sqrt (/ 1.0 t_m))) 2.0)
(*
(* l_m l_m)
(/ 2.0 (* (* k_m k_m) (/ (* t_m (pow (sin k_m) 2.0)) (cos k_m))))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (k_m <= 1.25e-5) {
tmp = pow((((l_m * sqrt(2.0)) / pow(k_m, 2.0)) * sqrt((1.0 / t_m))), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * pow(sin(k_m), 2.0)) / cos(k_m))));
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 1.25d-5) then
tmp = (((l_m * sqrt(2.0d0)) / (k_m ** 2.0d0)) * sqrt((1.0d0 / t_m))) ** 2.0d0
else
tmp = (l_m * l_m) * (2.0d0 / ((k_m * k_m) * ((t_m * (sin(k_m) ** 2.0d0)) / cos(k_m))))
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (k_m <= 1.25e-5) {
tmp = Math.pow((((l_m * Math.sqrt(2.0)) / Math.pow(k_m, 2.0)) * Math.sqrt((1.0 / t_m))), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * Math.pow(Math.sin(k_m), 2.0)) / Math.cos(k_m))));
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if k_m <= 1.25e-5: tmp = math.pow((((l_m * math.sqrt(2.0)) / math.pow(k_m, 2.0)) * math.sqrt((1.0 / t_m))), 2.0) else: tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * math.pow(math.sin(k_m), 2.0)) / math.cos(k_m)))) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (k_m <= 1.25e-5) tmp = Float64(Float64(Float64(l_m * sqrt(2.0)) / (k_m ^ 2.0)) * sqrt(Float64(1.0 / t_m))) ^ 2.0; else tmp = Float64(Float64(l_m * l_m) * Float64(2.0 / Float64(Float64(k_m * k_m) * Float64(Float64(t_m * (sin(k_m) ^ 2.0)) / cos(k_m))))); end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (k_m <= 1.25e-5) tmp = (((l_m * sqrt(2.0)) / (k_m ^ 2.0)) * sqrt((1.0 / t_m))) ^ 2.0; else tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * (sin(k_m) ^ 2.0)) / cos(k_m)))); end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 1.25e-5], N[Power[N[(N[(N[(l$95$m * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[(N[(k$95$m * k$95$m), $MachinePrecision] * N[(N[(t$95$m * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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 1.25 \cdot 10^{-5}:\\
\;\;\;\;{\left(\frac{l\_m \cdot \sqrt{2}}{{k\_m}^{2}} \cdot \sqrt{\frac{1}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{2}{\left(k\_m \cdot k\_m\right) \cdot \frac{t\_m \cdot {\sin k\_m}^{2}}{\cos k\_m}}\\
\end{array}
\end{array}
if k < 1.25000000000000006e-5Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in k around 0 37.0%
if 1.25000000000000006e-5 < k Initial program 32.7%
Simplified38.5%
Taylor expanded in t around 0 63.2%
associate-/l*63.2%
Simplified63.2%
unpow263.2%
Applied egg-rr63.2%
Final simplification44.2%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(*
t_s
(if (<= k_m 4.7e-5)
(pow (* (sqrt (/ 1.0 t_m)) (* l_m (/ (sqrt 2.0) (pow k_m 2.0)))) 2.0)
(*
(* l_m l_m)
(/ 2.0 (* (* k_m k_m) (/ (* t_m (pow (sin k_m) 2.0)) (cos k_m))))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (k_m <= 4.7e-5) {
tmp = pow((sqrt((1.0 / t_m)) * (l_m * (sqrt(2.0) / pow(k_m, 2.0)))), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * pow(sin(k_m), 2.0)) / cos(k_m))));
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 4.7d-5) then
tmp = (sqrt((1.0d0 / t_m)) * (l_m * (sqrt(2.0d0) / (k_m ** 2.0d0)))) ** 2.0d0
else
tmp = (l_m * l_m) * (2.0d0 / ((k_m * k_m) * ((t_m * (sin(k_m) ** 2.0d0)) / cos(k_m))))
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (k_m <= 4.7e-5) {
tmp = Math.pow((Math.sqrt((1.0 / t_m)) * (l_m * (Math.sqrt(2.0) / Math.pow(k_m, 2.0)))), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * Math.pow(Math.sin(k_m), 2.0)) / Math.cos(k_m))));
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if k_m <= 4.7e-5: tmp = math.pow((math.sqrt((1.0 / t_m)) * (l_m * (math.sqrt(2.0) / math.pow(k_m, 2.0)))), 2.0) else: tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * math.pow(math.sin(k_m), 2.0)) / math.cos(k_m)))) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (k_m <= 4.7e-5) tmp = Float64(sqrt(Float64(1.0 / t_m)) * Float64(l_m * Float64(sqrt(2.0) / (k_m ^ 2.0)))) ^ 2.0; else tmp = Float64(Float64(l_m * l_m) * Float64(2.0 / Float64(Float64(k_m * k_m) * Float64(Float64(t_m * (sin(k_m) ^ 2.0)) / cos(k_m))))); end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (k_m <= 4.7e-5) tmp = (sqrt((1.0 / t_m)) * (l_m * (sqrt(2.0) / (k_m ^ 2.0)))) ^ 2.0; else tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * (sin(k_m) ^ 2.0)) / cos(k_m)))); end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 4.7e-5], N[Power[N[(N[Sqrt[N[(1.0 / t$95$m), $MachinePrecision]], $MachinePrecision] * N[(l$95$m * N[(N[Sqrt[2.0], $MachinePrecision] / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[(N[(k$95$m * k$95$m), $MachinePrecision] * N[(N[(t$95$m * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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 4.7 \cdot 10^{-5}:\\
\;\;\;\;{\left(\sqrt{\frac{1}{t\_m}} \cdot \left(l\_m \cdot \frac{\sqrt{2}}{{k\_m}^{2}}\right)\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{2}{\left(k\_m \cdot k\_m\right) \cdot \frac{t\_m \cdot {\sin k\_m}^{2}}{\cos k\_m}}\\
\end{array}
\end{array}
if k < 4.69999999999999972e-5Initial program 37.9%
Simplified42.7%
add-sqr-sqrt23.8%
pow223.8%
Applied egg-rr25.9%
associate-*r/25.8%
*-commutative25.8%
times-frac26.4%
Simplified26.4%
Taylor expanded in k around 0 37.0%
associate-/l*36.5%
Simplified36.5%
if 4.69999999999999972e-5 < k Initial program 32.7%
Simplified38.5%
Taylor expanded in t around 0 63.2%
associate-/l*63.2%
Simplified63.2%
unpow263.2%
Applied egg-rr63.2%
Final simplification43.9%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(*
t_s
(if (<= t_m 3.5e-98)
(* (/ (pow l_m 2.0) t_m) (/ 2.0 (pow k_m 4.0)))
(if (<= t_m 2.4e+86)
(pow (* (/ l_m (/ k_m t_m)) (/ (sqrt (/ 2.0 (pow t_m 3.0))) k_m)) 2.0)
(* (* l_m l_m) (/ 2.0 (pow (* (pow k_m 2.0) (sqrt t_m)) 2.0)))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (t_m <= 3.5e-98) {
tmp = (pow(l_m, 2.0) / t_m) * (2.0 / pow(k_m, 4.0));
} else if (t_m <= 2.4e+86) {
tmp = pow(((l_m / (k_m / t_m)) * (sqrt((2.0 / pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / pow((pow(k_m, 2.0) * sqrt(t_m)), 2.0));
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (t_m <= 3.5d-98) then
tmp = ((l_m ** 2.0d0) / t_m) * (2.0d0 / (k_m ** 4.0d0))
else if (t_m <= 2.4d+86) then
tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0d0 / (t_m ** 3.0d0))) / k_m)) ** 2.0d0
else
tmp = (l_m * l_m) * (2.0d0 / (((k_m ** 2.0d0) * sqrt(t_m)) ** 2.0d0))
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (t_m <= 3.5e-98) {
tmp = (Math.pow(l_m, 2.0) / t_m) * (2.0 / Math.pow(k_m, 4.0));
} else if (t_m <= 2.4e+86) {
tmp = Math.pow(((l_m / (k_m / t_m)) * (Math.sqrt((2.0 / Math.pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / Math.pow((Math.pow(k_m, 2.0) * Math.sqrt(t_m)), 2.0));
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if t_m <= 3.5e-98: tmp = (math.pow(l_m, 2.0) / t_m) * (2.0 / math.pow(k_m, 4.0)) elif t_m <= 2.4e+86: tmp = math.pow(((l_m / (k_m / t_m)) * (math.sqrt((2.0 / math.pow(t_m, 3.0))) / k_m)), 2.0) else: tmp = (l_m * l_m) * (2.0 / math.pow((math.pow(k_m, 2.0) * math.sqrt(t_m)), 2.0)) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (t_m <= 3.5e-98) tmp = Float64(Float64((l_m ^ 2.0) / t_m) * Float64(2.0 / (k_m ^ 4.0))); elseif (t_m <= 2.4e+86) tmp = Float64(Float64(l_m / Float64(k_m / t_m)) * Float64(sqrt(Float64(2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = Float64(Float64(l_m * l_m) * Float64(2.0 / (Float64((k_m ^ 2.0) * sqrt(t_m)) ^ 2.0))); end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (t_m <= 3.5e-98) tmp = ((l_m ^ 2.0) / t_m) * (2.0 / (k_m ^ 4.0)); elseif (t_m <= 2.4e+86) tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = (l_m * l_m) * (2.0 / (((k_m ^ 2.0) * sqrt(t_m)) ^ 2.0)); end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[t$95$m, 3.5e-98], N[(N[(N[Power[l$95$m, 2.0], $MachinePrecision] / t$95$m), $MachinePrecision] * N[(2.0 / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 2.4e+86], N[Power[N[(N[(l$95$m / N[(k$95$m / t$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[N[(2.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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}\;t\_m \leq 3.5 \cdot 10^{-98}:\\
\;\;\;\;\frac{{l\_m}^{2}}{t\_m} \cdot \frac{2}{{k\_m}^{4}}\\
\mathbf{elif}\;t\_m \leq 2.4 \cdot 10^{+86}:\\
\;\;\;\;{\left(\frac{l\_m}{\frac{k\_m}{t\_m}} \cdot \frac{\sqrt{\frac{2}{{t\_m}^{3}}}}{k\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{2}{{\left({k\_m}^{2} \cdot \sqrt{t\_m}\right)}^{2}}\\
\end{array}
\end{array}
if t < 3.5000000000000002e-98Initial program 35.9%
Simplified41.0%
Taylor expanded in k around 0 60.4%
associate-*r/60.4%
*-commutative60.4%
*-commutative60.4%
times-frac59.0%
Simplified59.0%
if 3.5000000000000002e-98 < t < 2.4e86Initial program 65.6%
Simplified68.6%
add-sqr-sqrt61.7%
pow261.7%
Applied egg-rr68.3%
associate-*r/67.9%
*-commutative67.9%
times-frac70.6%
Simplified70.6%
Taylor expanded in k around 0 79.8%
if 2.4e86 < t Initial program 7.5%
Simplified15.0%
add-sqr-sqrt7.5%
pow27.5%
*-commutative7.5%
sqrt-prod7.5%
associate-*r*7.5%
sqrt-prod10.0%
sqrt-pow115.2%
metadata-eval15.2%
pow115.2%
sqrt-pow132.3%
metadata-eval32.3%
Applied egg-rr32.3%
associate-*l*32.4%
Simplified32.4%
Taylor expanded in k around 0 64.5%
Final simplification63.5%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(*
t_s
(if (<= l_m 1.55e-176)
(pow (* (/ l_m (/ k_m t_m)) (/ (sqrt (/ 2.0 (pow t_m 3.0))) k_m)) 2.0)
(*
(* l_m l_m)
(/ 2.0 (* (* k_m k_m) (/ (* t_m (pow (sin k_m) 2.0)) (cos k_m))))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (l_m <= 1.55e-176) {
tmp = pow(((l_m / (k_m / t_m)) * (sqrt((2.0 / pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * pow(sin(k_m), 2.0)) / cos(k_m))));
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (l_m <= 1.55d-176) then
tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0d0 / (t_m ** 3.0d0))) / k_m)) ** 2.0d0
else
tmp = (l_m * l_m) * (2.0d0 / ((k_m * k_m) * ((t_m * (sin(k_m) ** 2.0d0)) / cos(k_m))))
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (l_m <= 1.55e-176) {
tmp = Math.pow(((l_m / (k_m / t_m)) * (Math.sqrt((2.0 / Math.pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * Math.pow(Math.sin(k_m), 2.0)) / Math.cos(k_m))));
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if l_m <= 1.55e-176: tmp = math.pow(((l_m / (k_m / t_m)) * (math.sqrt((2.0 / math.pow(t_m, 3.0))) / k_m)), 2.0) else: tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * math.pow(math.sin(k_m), 2.0)) / math.cos(k_m)))) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (l_m <= 1.55e-176) tmp = Float64(Float64(l_m / Float64(k_m / t_m)) * Float64(sqrt(Float64(2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = Float64(Float64(l_m * l_m) * Float64(2.0 / Float64(Float64(k_m * k_m) * Float64(Float64(t_m * (sin(k_m) ^ 2.0)) / cos(k_m))))); end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (l_m <= 1.55e-176) tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = (l_m * l_m) * (2.0 / ((k_m * k_m) * ((t_m * (sin(k_m) ^ 2.0)) / cos(k_m)))); end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[l$95$m, 1.55e-176], N[Power[N[(N[(l$95$m / N[(k$95$m / t$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[N[(2.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[(N[(k$95$m * k$95$m), $MachinePrecision] * N[(N[(t$95$m * N[Power[N[Sin[k$95$m], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[Cos[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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}\;l\_m \leq 1.55 \cdot 10^{-176}:\\
\;\;\;\;{\left(\frac{l\_m}{\frac{k\_m}{t\_m}} \cdot \frac{\sqrt{\frac{2}{{t\_m}^{3}}}}{k\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{2}{\left(k\_m \cdot k\_m\right) \cdot \frac{t\_m \cdot {\sin k\_m}^{2}}{\cos k\_m}}\\
\end{array}
\end{array}
if l < 1.54999999999999996e-176Initial program 36.0%
Simplified42.4%
add-sqr-sqrt28.1%
pow228.1%
Applied egg-rr27.4%
associate-*r/27.3%
*-commutative27.3%
times-frac28.0%
Simplified28.0%
Taylor expanded in k around 0 32.9%
if 1.54999999999999996e-176 < l Initial program 37.1%
Simplified40.4%
Taylor expanded in t around 0 70.6%
associate-/l*70.6%
Simplified70.6%
unpow270.6%
Applied egg-rr70.6%
Final simplification48.9%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(*
t_s
(if (<= l_m 1.56e-176)
(pow (* (/ l_m (/ k_m t_m)) (/ (sqrt (/ 2.0 (pow t_m 3.0))) k_m)) 2.0)
(*
(* l_m l_m)
(/ 2.0 (* (pow k_m 2.0) (* t_m (* (sin k_m) (tan k_m)))))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (l_m <= 1.56e-176) {
tmp = pow(((l_m / (k_m / t_m)) * (sqrt((2.0 / pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / (pow(k_m, 2.0) * (t_m * (sin(k_m) * tan(k_m)))));
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (l_m <= 1.56d-176) then
tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0d0 / (t_m ** 3.0d0))) / k_m)) ** 2.0d0
else
tmp = (l_m * l_m) * (2.0d0 / ((k_m ** 2.0d0) * (t_m * (sin(k_m) * tan(k_m)))))
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (l_m <= 1.56e-176) {
tmp = Math.pow(((l_m / (k_m / t_m)) * (Math.sqrt((2.0 / Math.pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / (Math.pow(k_m, 2.0) * (t_m * (Math.sin(k_m) * Math.tan(k_m)))));
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if l_m <= 1.56e-176: tmp = math.pow(((l_m / (k_m / t_m)) * (math.sqrt((2.0 / math.pow(t_m, 3.0))) / k_m)), 2.0) else: tmp = (l_m * l_m) * (2.0 / (math.pow(k_m, 2.0) * (t_m * (math.sin(k_m) * math.tan(k_m))))) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (l_m <= 1.56e-176) tmp = Float64(Float64(l_m / Float64(k_m / t_m)) * Float64(sqrt(Float64(2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = Float64(Float64(l_m * l_m) * Float64(2.0 / Float64((k_m ^ 2.0) * Float64(t_m * Float64(sin(k_m) * tan(k_m)))))); end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (l_m <= 1.56e-176) tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = (l_m * l_m) * (2.0 / ((k_m ^ 2.0) * (t_m * (sin(k_m) * tan(k_m))))); end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[l$95$m, 1.56e-176], N[Power[N[(N[(l$95$m / N[(k$95$m / t$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[N[(2.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(t$95$m * N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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}\;l\_m \leq 1.56 \cdot 10^{-176}:\\
\;\;\;\;{\left(\frac{l\_m}{\frac{k\_m}{t\_m}} \cdot \frac{\sqrt{\frac{2}{{t\_m}^{3}}}}{k\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{2}{{k\_m}^{2} \cdot \left(t\_m \cdot \left(\sin k\_m \cdot \tan k\_m\right)\right)}\\
\end{array}
\end{array}
if l < 1.56000000000000006e-176Initial program 36.0%
Simplified42.4%
add-sqr-sqrt28.1%
pow228.1%
Applied egg-rr27.4%
associate-*r/27.3%
*-commutative27.3%
times-frac28.0%
Simplified28.0%
Taylor expanded in k around 0 32.9%
if 1.56000000000000006e-176 < l Initial program 37.1%
Simplified40.4%
add-log-exp24.7%
exp-prod27.1%
Applied egg-rr27.1%
Taylor expanded in k around inf 70.6%
Final simplification48.9%
l_m = (fabs.f64 l)
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_m k_m)
:precision binary64
(*
t_s
(if (<= l_m 1.2e-178)
(pow (* (/ l_m (/ k_m t_m)) (/ (sqrt (/ 2.0 (pow t_m 3.0))) k_m)) 2.0)
(*
(* l_m l_m)
(/ 2.0 (* (* (sin k_m) (tan k_m)) (* t_m (pow k_m 2.0))))))))l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (l_m <= 1.2e-178) {
tmp = pow(((l_m / (k_m / t_m)) * (sqrt((2.0 / pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((sin(k_m) * tan(k_m)) * (t_m * pow(k_m, 2.0))));
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (l_m <= 1.2d-178) then
tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0d0 / (t_m ** 3.0d0))) / k_m)) ** 2.0d0
else
tmp = (l_m * l_m) * (2.0d0 / ((sin(k_m) * tan(k_m)) * (t_m * (k_m ** 2.0d0))))
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (l_m <= 1.2e-178) {
tmp = Math.pow(((l_m / (k_m / t_m)) * (Math.sqrt((2.0 / Math.pow(t_m, 3.0))) / k_m)), 2.0);
} else {
tmp = (l_m * l_m) * (2.0 / ((Math.sin(k_m) * Math.tan(k_m)) * (t_m * Math.pow(k_m, 2.0))));
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if l_m <= 1.2e-178: tmp = math.pow(((l_m / (k_m / t_m)) * (math.sqrt((2.0 / math.pow(t_m, 3.0))) / k_m)), 2.0) else: tmp = (l_m * l_m) * (2.0 / ((math.sin(k_m) * math.tan(k_m)) * (t_m * math.pow(k_m, 2.0)))) return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (l_m <= 1.2e-178) tmp = Float64(Float64(l_m / Float64(k_m / t_m)) * Float64(sqrt(Float64(2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = Float64(Float64(l_m * l_m) * Float64(2.0 / Float64(Float64(sin(k_m) * tan(k_m)) * Float64(t_m * (k_m ^ 2.0))))); end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (l_m <= 1.2e-178) tmp = ((l_m / (k_m / t_m)) * (sqrt((2.0 / (t_m ^ 3.0))) / k_m)) ^ 2.0; else tmp = (l_m * l_m) * (2.0 / ((sin(k_m) * tan(k_m)) * (t_m * (k_m ^ 2.0)))); end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[l$95$m, 1.2e-178], N[Power[N[(N[(l$95$m / N[(k$95$m / t$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[N[(2.0 / N[Power[t$95$m, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / k$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[(N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision] * N[(t$95$m * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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}\;l\_m \leq 1.2 \cdot 10^{-178}:\\
\;\;\;\;{\left(\frac{l\_m}{\frac{k\_m}{t\_m}} \cdot \frac{\sqrt{\frac{2}{{t\_m}^{3}}}}{k\_m}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{2}{\left(\sin k\_m \cdot \tan k\_m\right) \cdot \left(t\_m \cdot {k\_m}^{2}\right)}\\
\end{array}
\end{array}
if l < 1.20000000000000002e-178Initial program 36.0%
Simplified42.4%
add-sqr-sqrt28.1%
pow228.1%
Applied egg-rr27.4%
associate-*r/27.3%
*-commutative27.3%
times-frac28.0%
Simplified28.0%
Taylor expanded in k around 0 32.9%
if 1.20000000000000002e-178 < l Initial program 37.1%
Simplified40.4%
add-log-exp24.7%
exp-prod27.1%
Applied egg-rr27.1%
Taylor expanded in k around inf 70.6%
associate-*r*70.6%
*-commutative70.6%
Simplified70.6%
Final simplification48.9%
l_m = (fabs.f64 l) 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_m k_m) :precision binary64 (* t_s (* (* l_m l_m) (/ 2.0 (pow (* (pow k_m 2.0) (sqrt t_m)) 2.0)))))
l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
return t_s * ((l_m * l_m) * (2.0 / pow((pow(k_m, 2.0) * sqrt(t_m)), 2.0)));
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
code = t_s * ((l_m * l_m) * (2.0d0 / (((k_m ** 2.0d0) * sqrt(t_m)) ** 2.0d0)))
end function
l_m = Math.abs(l);
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_m, double k_m) {
return t_s * ((l_m * l_m) * (2.0 / Math.pow((Math.pow(k_m, 2.0) * Math.sqrt(t_m)), 2.0)));
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): return t_s * ((l_m * l_m) * (2.0 / math.pow((math.pow(k_m, 2.0) * math.sqrt(t_m)), 2.0)))
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) return Float64(t_s * Float64(Float64(l_m * l_m) * Float64(2.0 / (Float64((k_m ^ 2.0) * sqrt(t_m)) ^ 2.0)))) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l_m, k_m) tmp = t_s * ((l_m * l_m) * (2.0 / (((k_m ^ 2.0) * sqrt(t_m)) ^ 2.0))); end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[Power[N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(l\_m \cdot l\_m\right) \cdot \frac{2}{{\left({k\_m}^{2} \cdot \sqrt{t\_m}\right)}^{2}}\right)
\end{array}
Initial program 36.5%
Simplified41.6%
add-sqr-sqrt19.2%
pow219.2%
*-commutative19.2%
sqrt-prod14.2%
associate-*r*14.2%
sqrt-prod14.6%
sqrt-pow116.7%
metadata-eval16.7%
pow116.7%
sqrt-pow121.7%
metadata-eval21.7%
Applied egg-rr21.7%
associate-*l*21.7%
Simplified21.7%
Taylor expanded in k around 0 28.7%
Final simplification28.7%
l_m = (fabs.f64 l) 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_m k_m) :precision binary64 (* t_s (* (* l_m l_m) (/ 2.0 (* t_m (* (pow k_m 2.0) (pow k_m 2.0)))))))
l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
return t_s * ((l_m * l_m) * (2.0 / (t_m * (pow(k_m, 2.0) * pow(k_m, 2.0)))));
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
code = t_s * ((l_m * l_m) * (2.0d0 / (t_m * ((k_m ** 2.0d0) * (k_m ** 2.0d0)))))
end function
l_m = Math.abs(l);
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_m, double k_m) {
return t_s * ((l_m * l_m) * (2.0 / (t_m * (Math.pow(k_m, 2.0) * Math.pow(k_m, 2.0)))));
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): return t_s * ((l_m * l_m) * (2.0 / (t_m * (math.pow(k_m, 2.0) * math.pow(k_m, 2.0)))))
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) return Float64(t_s * Float64(Float64(l_m * l_m) * Float64(2.0 / Float64(t_m * Float64((k_m ^ 2.0) * (k_m ^ 2.0)))))) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l_m, k_m) tmp = t_s * ((l_m * l_m) * (2.0 / (t_m * ((k_m ^ 2.0) * (k_m ^ 2.0))))); end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[(t$95$m * N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(l\_m \cdot l\_m\right) \cdot \frac{2}{t\_m \cdot \left({k\_m}^{2} \cdot {k\_m}^{2}\right)}\right)
\end{array}
Initial program 36.5%
Simplified41.6%
Taylor expanded in k around 0 60.5%
metadata-eval60.5%
pow-prod-up60.6%
Applied egg-rr60.6%
Final simplification60.6%
l_m = (fabs.f64 l) 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_m k_m) :precision binary64 (* t_s (* (pow l_m 2.0) (/ (/ 2.0 (pow k_m 4.0)) t_m))))
l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
return t_s * (pow(l_m, 2.0) * ((2.0 / pow(k_m, 4.0)) / t_m));
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
code = t_s * ((l_m ** 2.0d0) * ((2.0d0 / (k_m ** 4.0d0)) / t_m))
end function
l_m = Math.abs(l);
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_m, double k_m) {
return t_s * (Math.pow(l_m, 2.0) * ((2.0 / Math.pow(k_m, 4.0)) / t_m));
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): return t_s * (math.pow(l_m, 2.0) * ((2.0 / math.pow(k_m, 4.0)) / t_m))
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) return Float64(t_s * Float64((l_m ^ 2.0) * Float64(Float64(2.0 / (k_m ^ 4.0)) / t_m))) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l_m, k_m) tmp = t_s * ((l_m ^ 2.0) * ((2.0 / (k_m ^ 4.0)) / t_m)); end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * N[(N[Power[l$95$m, 2.0], $MachinePrecision] * N[(N[(2.0 / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left({l\_m}^{2} \cdot \frac{\frac{2}{{k\_m}^{4}}}{t\_m}\right)
\end{array}
Initial program 36.5%
Simplified36.5%
Applied egg-rr77.2%
associate-/r/77.2%
associate-/r*77.2%
associate-/r/77.6%
Simplified77.6%
pow1/338.2%
add-sqr-sqrt38.2%
unpow-prod-down38.2%
Applied egg-rr38.2%
unpow1/338.4%
unpow1/339.0%
Simplified39.0%
Taylor expanded in k around 0 60.5%
associate-/l*60.5%
unpow260.5%
rem-square-sqrt60.5%
associate-/r*60.5%
Simplified60.5%
l_m = (fabs.f64 l) 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_m k_m) :precision binary64 (* t_s (* (* l_m l_m) (/ 2.0 (* t_m (pow k_m 4.0))))))
l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
return t_s * ((l_m * l_m) * (2.0 / (t_m * pow(k_m, 4.0))));
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
code = t_s * ((l_m * l_m) * (2.0d0 / (t_m * (k_m ** 4.0d0))))
end function
l_m = Math.abs(l);
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_m, double k_m) {
return t_s * ((l_m * l_m) * (2.0 / (t_m * Math.pow(k_m, 4.0))));
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): return t_s * ((l_m * l_m) * (2.0 / (t_m * math.pow(k_m, 4.0))))
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) return Float64(t_s * Float64(Float64(l_m * l_m) * Float64(2.0 / Float64(t_m * (k_m ^ 4.0))))) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l_m, k_m) tmp = t_s * ((l_m * l_m) * (2.0 / (t_m * (k_m ^ 4.0)))); end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(2.0 / N[(t$95$m * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(l\_m \cdot l\_m\right) \cdot \frac{2}{t\_m \cdot {k\_m}^{4}}\right)
\end{array}
Initial program 36.5%
Simplified41.6%
Taylor expanded in k around 0 60.5%
Final simplification60.5%
l_m = (fabs.f64 l) 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_m k_m) :precision binary64 (* t_s (if (<= k_m 1.65e-36) (* (* l_m l_m) (/ 4.0 0.0)) 0.0)))
l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
double tmp;
if (k_m <= 1.65e-36) {
tmp = (l_m * l_m) * (4.0 / 0.0);
} else {
tmp = 0.0;
}
return t_s * tmp;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 1.65d-36) then
tmp = (l_m * l_m) * (4.0d0 / 0.0d0)
else
tmp = 0.0d0
end if
code = t_s * tmp
end function
l_m = Math.abs(l);
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_m, double k_m) {
double tmp;
if (k_m <= 1.65e-36) {
tmp = (l_m * l_m) * (4.0 / 0.0);
} else {
tmp = 0.0;
}
return t_s * tmp;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): tmp = 0 if k_m <= 1.65e-36: tmp = (l_m * l_m) * (4.0 / 0.0) else: tmp = 0.0 return t_s * tmp
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) tmp = 0.0 if (k_m <= 1.65e-36) tmp = Float64(Float64(l_m * l_m) * Float64(4.0 / 0.0)); else tmp = 0.0; end return Float64(t_s * tmp) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l_m, k_m) tmp = 0.0; if (k_m <= 1.65e-36) tmp = (l_m * l_m) * (4.0 / 0.0); else tmp = 0.0; end tmp_2 = t_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 1.65e-36], N[(N[(l$95$m * l$95$m), $MachinePrecision] * N[(4.0 / 0.0), $MachinePrecision]), $MachinePrecision], 0.0]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
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 1.65 \cdot 10^{-36}:\\
\;\;\;\;\left(l\_m \cdot l\_m\right) \cdot \frac{4}{0}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if k < 1.64999999999999995e-36Initial program 39.0%
Simplified43.5%
add-log-exp22.6%
exp-prod25.2%
Applied egg-rr25.2%
Taylor expanded in t around 0 19.4%
div-inv19.4%
metadata-eval19.4%
metadata-eval19.4%
metadata-eval19.4%
clear-num19.4%
metadata-eval19.4%
Applied egg-rr19.4%
associate-*r/19.4%
metadata-eval19.4%
Simplified19.4%
if 1.64999999999999995e-36 < k Initial program 30.8%
Simplified37.2%
add-log-exp33.2%
exp-prod25.1%
Applied egg-rr25.1%
Taylor expanded in t around 0 8.7%
add-cube-cbrt8.7%
pow28.7%
clear-num8.7%
metadata-eval8.7%
metadata-eval8.7%
metadata-eval8.7%
cbrt-div8.7%
metadata-eval8.7%
metadata-eval8.7%
clear-num8.7%
metadata-eval8.7%
metadata-eval8.7%
metadata-eval8.7%
cbrt-div8.7%
metadata-eval8.7%
metadata-eval8.7%
Applied egg-rr8.7%
pow-plus8.7%
metadata-eval8.7%
cube-div8.7%
metadata-eval8.7%
rem-cube-cbrt8.7%
unpow-18.7%
pow-base-042.9%
Simplified42.9%
Taylor expanded in l around 0 45.0%
Final simplification27.3%
l_m = (fabs.f64 l) 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_m k_m) :precision binary64 (* t_s 0.0))
l_m = fabs(l);
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l_m, double k_m) {
return t_s * 0.0;
}
l_m = abs(l)
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l_m, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l_m
real(8), intent (in) :: k_m
code = t_s * 0.0d0
end function
l_m = Math.abs(l);
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_m, double k_m) {
return t_s * 0.0;
}
l_m = math.fabs(l) k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l_m, k_m): return t_s * 0.0
l_m = abs(l) k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l_m, k_m) return Float64(t_s * 0.0) end
l_m = abs(l); k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l_m, k_m) tmp = t_s * 0.0; end
l_m = N[Abs[l], $MachinePrecision]
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$95$m_, k$95$m_] := N[(t$95$s * 0.0), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot 0
\end{array}
Initial program 36.5%
Simplified41.6%
add-log-exp25.9%
exp-prod25.2%
Applied egg-rr25.2%
Taylor expanded in t around 0 16.1%
add-cube-cbrt16.1%
pow216.1%
clear-num16.1%
metadata-eval16.1%
metadata-eval16.1%
metadata-eval16.1%
cbrt-div16.1%
metadata-eval16.1%
metadata-eval16.1%
clear-num16.1%
metadata-eval16.1%
metadata-eval16.1%
metadata-eval16.1%
cbrt-div16.1%
metadata-eval16.1%
metadata-eval16.1%
Applied egg-rr16.1%
pow-plus16.1%
metadata-eval16.1%
cube-div16.1%
metadata-eval16.1%
rem-cube-cbrt16.1%
unpow-116.1%
pow-base-026.6%
Simplified26.6%
Taylor expanded in l around 0 27.9%
herbie shell --seed 2024150
(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))))