
(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 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l k) :precision binary64 (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (- (+ 1.0 (pow (/ k t) 2.0)) 1.0))))
double code(double t, double l, double k) {
return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) - 1.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) - 1.0d0))
end function
public static double code(double t, double l, double k) {
return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) - 1.0));
}
def code(t, l, k): return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) - 1.0))
function code(t, l, k) return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) - 1.0))) end
function tmp = code(t, l, k) tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) - 1.0)); end
code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) - 1\right)}
\end{array}
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= k_m 1.6)
(pow
(* (/ (* l (sqrt 2.0)) (* k_m (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(if (<= k_m 1.85e+121)
(* (/ (/ 2.0 (pow k_m 2.0)) (* (tan k_m) (* (sin k_m) t_m))) (* l l))
(*
(pow (* (* (sqrt 2.0) (/ t_m k_m)) (/ l (pow t_m 1.5))) 2.0)
(/ 1.0 (* (sin k_m) (tan k_m))))))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 1.6) {
tmp = pow((((l * sqrt(2.0)) / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else if (k_m <= 1.85e+121) {
tmp = ((2.0 / pow(k_m, 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l);
} else {
tmp = pow(((sqrt(2.0) * (t_m / k_m)) * (l / pow(t_m, 1.5))), 2.0) * (1.0 / (sin(k_m) * tan(k_m)));
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 1.6d0) then
tmp = (((l * sqrt(2.0d0)) / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))) ** 2.0d0
else if (k_m <= 1.85d+121) then
tmp = ((2.0d0 / (k_m ** 2.0d0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l)
else
tmp = (((sqrt(2.0d0) * (t_m / k_m)) * (l / (t_m ** 1.5d0))) ** 2.0d0) * (1.0d0 / (sin(k_m) * tan(k_m)))
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 1.6) {
tmp = Math.pow((((l * Math.sqrt(2.0)) / (k_m * Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else if (k_m <= 1.85e+121) {
tmp = ((2.0 / Math.pow(k_m, 2.0)) / (Math.tan(k_m) * (Math.sin(k_m) * t_m))) * (l * l);
} else {
tmp = Math.pow(((Math.sqrt(2.0) * (t_m / k_m)) * (l / Math.pow(t_m, 1.5))), 2.0) * (1.0 / (Math.sin(k_m) * Math.tan(k_m)));
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if k_m <= 1.6: tmp = math.pow((((l * math.sqrt(2.0)) / (k_m * math.sin(k_m))) * math.sqrt((math.cos(k_m) / t_m))), 2.0) elif k_m <= 1.85e+121: tmp = ((2.0 / math.pow(k_m, 2.0)) / (math.tan(k_m) * (math.sin(k_m) * t_m))) * (l * l) else: tmp = math.pow(((math.sqrt(2.0) * (t_m / k_m)) * (l / math.pow(t_m, 1.5))), 2.0) * (1.0 / (math.sin(k_m) * math.tan(k_m))) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (k_m <= 1.6) tmp = Float64(Float64(Float64(l * sqrt(2.0)) / Float64(k_m * sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; elseif (k_m <= 1.85e+121) tmp = Float64(Float64(Float64(2.0 / (k_m ^ 2.0)) / Float64(tan(k_m) * Float64(sin(k_m) * t_m))) * Float64(l * l)); else tmp = Float64((Float64(Float64(sqrt(2.0) * Float64(t_m / k_m)) * Float64(l / (t_m ^ 1.5))) ^ 2.0) * Float64(1.0 / Float64(sin(k_m) * tan(k_m)))); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if (k_m <= 1.6) tmp = (((l * sqrt(2.0)) / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))) ^ 2.0; elseif (k_m <= 1.85e+121) tmp = ((2.0 / (k_m ^ 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l); else tmp = (((sqrt(2.0) * (t_m / k_m)) * (l / (t_m ^ 1.5))) ^ 2.0) * (1.0 / (sin(k_m) * tan(k_m))); end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 1.6], N[Power[N[(N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k$95$m * 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], If[LessEqual[k$95$m, 1.85e+121], N[(N[(N[(2.0 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(N[(N[Sqrt[2.0], $MachinePrecision] * N[(t$95$m / k$95$m), $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[t$95$m, 1.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 1.6:\\
\;\;\;\;{\left(\frac{\ell \cdot \sqrt{2}}{k\_m \cdot \sin k\_m} \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{elif}\;k\_m \leq 1.85 \cdot 10^{+121}:\\
\;\;\;\;\frac{\frac{2}{{k\_m}^{2}}}{\tan k\_m \cdot \left(\sin k\_m \cdot t\_m\right)} \cdot \left(\ell \cdot \ell\right)\\
\mathbf{else}:\\
\;\;\;\;{\left(\left(\sqrt{2} \cdot \frac{t\_m}{k\_m}\right) \cdot \frac{\ell}{{t\_m}^{1.5}}\right)}^{2} \cdot \frac{1}{\sin k\_m \cdot \tan k\_m}\\
\end{array}
\end{array}
if k < 1.6000000000000001Initial program 36.9%
*-commutative36.9%
associate-/r*36.9%
Simplified42.3%
add-sqr-sqrt26.2%
sqrt-div19.7%
sqrt-div19.7%
Applied egg-rr30.3%
unpow230.3%
associate-/r*30.3%
associate-/r/31.3%
associate-/r/31.3%
*-commutative31.3%
Simplified31.3%
Taylor expanded in t around 0 47.8%
if 1.6000000000000001 < k < 1.85000000000000006e121Initial program 28.8%
Simplified39.0%
add-log-exp17.3%
exp-prod21.0%
associate-*r*21.0%
*-commutative21.0%
Applied egg-rr21.0%
Taylor expanded in k around inf 78.2%
associate-*r*78.2%
Simplified78.2%
*-un-lft-identity78.2%
associate-/r*81.1%
*-commutative81.1%
Applied egg-rr81.1%
if 1.85000000000000006e121 < k Initial program 32.9%
*-commutative32.9%
associate-/r*32.9%
Simplified41.0%
add-sqr-sqrt40.9%
sqrt-div16.4%
sqrt-div16.4%
Applied egg-rr16.8%
unpow216.8%
associate-/r*16.8%
associate-/r/16.8%
associate-/r/16.8%
*-commutative16.8%
Simplified16.8%
div-inv16.8%
unpow-prod-down16.8%
associate-*l/16.8%
pow1/216.8%
pow-flip16.8%
*-commutative16.8%
metadata-eval16.8%
Applied egg-rr16.8%
associate-/l*16.8%
*-commutative16.8%
associate-*l/16.8%
associate-/l*16.8%
unpow216.8%
pow-sqr33.1%
metadata-eval33.1%
unpow-133.1%
*-commutative33.1%
Simplified33.1%
Final simplification49.7%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(let* ((t_2 (/ (sqrt 2.0) k_m)) (t_3 (* t_m (pow (cbrt l) -2.0))))
(*
t_s
(if (<= k_m 0.058)
(pow
(* (/ (* l (sqrt 2.0)) (* k_m (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(/
(*
(*
t_2
(/ t_m (pow (* t_3 (cbrt (* (log (exp (sin k_m))) (tan k_m)))) 2.0)))
(* t_2 (/ t_m t_3)))
(cbrt (* (sin k_m) (tan k_m))))))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double t_2 = sqrt(2.0) / k_m;
double t_3 = t_m * pow(cbrt(l), -2.0);
double tmp;
if (k_m <= 0.058) {
tmp = pow((((l * sqrt(2.0)) / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_2 * (t_m / pow((t_3 * cbrt((log(exp(sin(k_m))) * tan(k_m)))), 2.0))) * (t_2 * (t_m / t_3))) / cbrt((sin(k_m) * tan(k_m)));
}
return t_s * tmp;
}
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double t_2 = Math.sqrt(2.0) / k_m;
double t_3 = t_m * Math.pow(Math.cbrt(l), -2.0);
double tmp;
if (k_m <= 0.058) {
tmp = Math.pow((((l * Math.sqrt(2.0)) / (k_m * Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_2 * (t_m / Math.pow((t_3 * Math.cbrt((Math.log(Math.exp(Math.sin(k_m))) * Math.tan(k_m)))), 2.0))) * (t_2 * (t_m / t_3))) / Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
}
return t_s * tmp;
}
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) t_2 = Float64(sqrt(2.0) / k_m) t_3 = Float64(t_m * (cbrt(l) ^ -2.0)) tmp = 0.0 if (k_m <= 0.058) tmp = Float64(Float64(Float64(l * sqrt(2.0)) / Float64(k_m * sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_2 * Float64(t_m / (Float64(t_3 * cbrt(Float64(log(exp(sin(k_m))) * tan(k_m)))) ^ 2.0))) * Float64(t_2 * Float64(t_m / t_3))) / cbrt(Float64(sin(k_m) * tan(k_m)))); end return Float64(t_s * tmp) end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := Block[{t$95$2 = N[(N[Sqrt[2.0], $MachinePrecision] / k$95$m), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$m * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 0.058], N[Power[N[(N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k$95$m * 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$2 * N[(t$95$m / N[Power[N[(t$95$3 * N[Power[N[(N[Log[N[Exp[N[Sin[k$95$m], $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$2 * N[(t$95$m / t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[N[(N[Sin[k$95$m], $MachinePrecision] * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \frac{\sqrt{2}}{k\_m}\\
t_3 := t\_m \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 0.058:\\
\;\;\;\;{\left(\frac{\ell \cdot \sqrt{2}}{k\_m \cdot \sin k\_m} \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(t\_2 \cdot \frac{t\_m}{{\left(t\_3 \cdot \sqrt[3]{\log \left(e^{\sin k\_m}\right) \cdot \tan k\_m}\right)}^{2}}\right) \cdot \left(t\_2 \cdot \frac{t\_m}{t\_3}\right)}{\sqrt[3]{\sin k\_m \cdot \tan k\_m}}\\
\end{array}
\end{array}
\end{array}
if k < 0.0580000000000000029Initial program 37.0%
*-commutative37.0%
associate-/r*37.1%
Simplified42.5%
add-sqr-sqrt26.3%
sqrt-div19.8%
sqrt-div19.8%
Applied egg-rr30.5%
unpow230.5%
associate-/r*30.5%
associate-/r/31.5%
associate-/r/31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in t around 0 48.0%
if 0.0580000000000000029 < k Initial program 30.6%
*-commutative30.6%
associate-/r*30.7%
Simplified39.6%
add-sqr-sqrt39.6%
add-cube-cbrt39.5%
times-frac39.5%
Applied egg-rr77.6%
associate-/r/77.6%
associate-/r*77.6%
associate-/r/77.7%
Simplified77.7%
*-commutative77.7%
cbrt-prod77.8%
Applied egg-rr77.8%
associate-*r/77.7%
Applied egg-rr79.7%
add-log-exp79.7%
Applied egg-rr79.7%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(let* ((t_2 (cbrt (* (sin k_m) (tan k_m))))
(t_3 (/ (sqrt 2.0) k_m))
(t_4 (* t_m (pow (cbrt l) -2.0))))
(*
t_s
(if (<= k_m 1.6)
(pow
(* (/ (* l (sqrt 2.0)) (* k_m (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(/ (* (* t_3 (/ t_m t_4)) (* t_3 (/ t_m (pow (* t_4 t_2) 2.0)))) t_2)))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double t_2 = cbrt((sin(k_m) * tan(k_m)));
double t_3 = sqrt(2.0) / k_m;
double t_4 = t_m * pow(cbrt(l), -2.0);
double tmp;
if (k_m <= 1.6) {
tmp = pow((((l * sqrt(2.0)) / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (t_m / t_4)) * (t_3 * (t_m / pow((t_4 * t_2), 2.0)))) / t_2;
}
return t_s * tmp;
}
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double t_2 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double t_3 = Math.sqrt(2.0) / k_m;
double t_4 = t_m * Math.pow(Math.cbrt(l), -2.0);
double tmp;
if (k_m <= 1.6) {
tmp = Math.pow((((l * Math.sqrt(2.0)) / (k_m * Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (t_m / t_4)) * (t_3 * (t_m / Math.pow((t_4 * t_2), 2.0)))) / t_2;
}
return t_s * tmp;
}
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) t_2 = cbrt(Float64(sin(k_m) * tan(k_m))) t_3 = Float64(sqrt(2.0) / k_m) t_4 = Float64(t_m * (cbrt(l) ^ -2.0)) tmp = 0.0 if (k_m <= 1.6) tmp = Float64(Float64(Float64(l * sqrt(2.0)) / Float64(k_m * sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_3 * Float64(t_m / t_4)) * Float64(t_3 * Float64(t_m / (Float64(t_4 * t_2) ^ 2.0)))) / t_2); end return Float64(t_s * tmp) end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := 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]}, Block[{t$95$4 = N[(t$95$m * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 1.6], N[Power[N[(N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k$95$m * 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[(t$95$m / t$95$4), $MachinePrecision]), $MachinePrecision] * N[(t$95$3 * N[(t$95$m / N[Power[N[(t$95$4 * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]]), $MachinePrecision]]]]
\begin{array}{l}
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_4 := t\_m \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 1.6:\\
\;\;\;\;{\left(\frac{\ell \cdot \sqrt{2}}{k\_m \cdot \sin k\_m} \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(t\_3 \cdot \frac{t\_m}{t\_4}\right) \cdot \left(t\_3 \cdot \frac{t\_m}{{\left(t\_4 \cdot t\_2\right)}^{2}}\right)}{t\_2}\\
\end{array}
\end{array}
\end{array}
if k < 1.6000000000000001Initial program 36.9%
*-commutative36.9%
associate-/r*36.9%
Simplified42.3%
add-sqr-sqrt26.2%
sqrt-div19.7%
sqrt-div19.7%
Applied egg-rr30.3%
unpow230.3%
associate-/r*30.3%
associate-/r/31.3%
associate-/r/31.3%
*-commutative31.3%
Simplified31.3%
Taylor expanded in t around 0 47.8%
if 1.6000000000000001 < k Initial program 31.0%
*-commutative31.0%
associate-/r*31.0%
Simplified40.1%
add-sqr-sqrt40.1%
add-cube-cbrt40.0%
times-frac40.0%
Applied egg-rr77.3%
associate-/r/77.4%
associate-/r*77.4%
associate-/r/77.4%
Simplified77.4%
*-commutative77.4%
cbrt-prod77.5%
Applied egg-rr77.5%
associate-*r/77.4%
Applied egg-rr79.4%
Final simplification56.2%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(let* ((t_2 (cbrt (* (sin k_m) (tan k_m))))
(t_3 (/ (sqrt 2.0) k_m))
(t_4 (pow (cbrt l) -2.0)))
(*
t_s
(if (<= k_m 1.6)
(pow
(* (/ (* l (sqrt 2.0)) (* k_m (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(/ (* (* t_3 (/ t_m (pow (* (* t_m t_4) t_2) 2.0))) (/ t_3 t_4)) t_2)))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double t_2 = cbrt((sin(k_m) * tan(k_m)));
double t_3 = sqrt(2.0) / k_m;
double t_4 = pow(cbrt(l), -2.0);
double tmp;
if (k_m <= 1.6) {
tmp = pow((((l * sqrt(2.0)) / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (t_m / pow(((t_m * t_4) * t_2), 2.0))) * (t_3 / t_4)) / t_2;
}
return t_s * tmp;
}
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double t_2 = Math.cbrt((Math.sin(k_m) * Math.tan(k_m)));
double t_3 = Math.sqrt(2.0) / k_m;
double t_4 = Math.pow(Math.cbrt(l), -2.0);
double tmp;
if (k_m <= 1.6) {
tmp = Math.pow((((l * Math.sqrt(2.0)) / (k_m * Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (t_m / Math.pow(((t_m * t_4) * t_2), 2.0))) * (t_3 / t_4)) / t_2;
}
return t_s * tmp;
}
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) t_2 = cbrt(Float64(sin(k_m) * tan(k_m))) t_3 = Float64(sqrt(2.0) / k_m) t_4 = cbrt(l) ^ -2.0 tmp = 0.0 if (k_m <= 1.6) tmp = Float64(Float64(Float64(l * sqrt(2.0)) / Float64(k_m * sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_3 * Float64(t_m / (Float64(Float64(t_m * t_4) * t_2) ^ 2.0))) * Float64(t_3 / t_4)) / t_2); end return Float64(t_s * tmp) end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := 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]}, Block[{t$95$4 = N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]}, N[(t$95$s * If[LessEqual[k$95$m, 1.6], N[Power[N[(N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k$95$m * 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[(t$95$m / N[Power[N[(N[(t$95$m * t$95$4), $MachinePrecision] * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$3 / t$95$4), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]]), $MachinePrecision]]]]
\begin{array}{l}
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_4 := {\left(\sqrt[3]{\ell}\right)}^{-2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 1.6:\\
\;\;\;\;{\left(\frac{\ell \cdot \sqrt{2}}{k\_m \cdot \sin k\_m} \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(t\_3 \cdot \frac{t\_m}{{\left(\left(t\_m \cdot t\_4\right) \cdot t\_2\right)}^{2}}\right) \cdot \frac{t\_3}{t\_4}}{t\_2}\\
\end{array}
\end{array}
\end{array}
if k < 1.6000000000000001Initial program 36.9%
*-commutative36.9%
associate-/r*36.9%
Simplified42.3%
add-sqr-sqrt26.2%
sqrt-div19.7%
sqrt-div19.7%
Applied egg-rr30.3%
unpow230.3%
associate-/r*30.3%
associate-/r/31.3%
associate-/r/31.3%
*-commutative31.3%
Simplified31.3%
Taylor expanded in t around 0 47.8%
if 1.6000000000000001 < k Initial program 31.0%
*-commutative31.0%
associate-/r*31.0%
Simplified40.1%
add-sqr-sqrt40.1%
add-cube-cbrt40.0%
times-frac40.0%
Applied egg-rr77.3%
associate-/r/77.4%
associate-/r*77.4%
associate-/r/77.4%
Simplified77.4%
*-commutative77.4%
cbrt-prod77.5%
Applied egg-rr77.5%
associate-*r/77.4%
Applied egg-rr79.4%
associate-/r*79.3%
pow179.3%
pow179.3%
pow-div79.3%
metadata-eval79.3%
metadata-eval79.3%
div-inv79.4%
Applied egg-rr79.4%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(let* ((t_2 (cbrt (* (sin k_m) (tan k_m)))) (t_3 (/ (sqrt 2.0) k_m)))
(*
t_s
(if (<= k_m 1.6)
(pow
(* (/ (* l (sqrt 2.0)) (* k_m (sin k_m))) (sqrt (/ (cos k_m) t_m)))
2.0)
(/
(*
(* t_3 (/ t_m (pow (* (* t_m (pow (cbrt l) -2.0)) t_2) 2.0)))
(* t_3 (pow l 0.6666666666666666)))
t_2)))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double t_2 = cbrt((sin(k_m) * tan(k_m)));
double t_3 = sqrt(2.0) / k_m;
double tmp;
if (k_m <= 1.6) {
tmp = pow((((l * sqrt(2.0)) / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (t_m / pow(((t_m * pow(cbrt(l), -2.0)) * t_2), 2.0))) * (t_3 * pow(l, 0.6666666666666666))) / t_2;
}
return t_s * tmp;
}
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double 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 <= 1.6) {
tmp = Math.pow((((l * Math.sqrt(2.0)) / (k_m * Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
} else {
tmp = ((t_3 * (t_m / Math.pow(((t_m * Math.pow(Math.cbrt(l), -2.0)) * t_2), 2.0))) * (t_3 * Math.pow(l, 0.6666666666666666))) / t_2;
}
return t_s * tmp;
}
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) t_2 = cbrt(Float64(sin(k_m) * tan(k_m))) t_3 = Float64(sqrt(2.0) / k_m) tmp = 0.0 if (k_m <= 1.6) tmp = Float64(Float64(Float64(l * sqrt(2.0)) / Float64(k_m * sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(t_3 * Float64(t_m / (Float64(Float64(t_m * (cbrt(l) ^ -2.0)) * t_2) ^ 2.0))) * Float64(t_3 * (l ^ 0.6666666666666666))) / t_2); end return Float64(t_s * tmp) end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := 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, 1.6], N[Power[N[(N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[(k$95$m * 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[(t$95$m / N[Power[N[(N[(t$95$m * N[Power[N[Power[l, 1/3], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$3 * N[Power[l, 0.6666666666666666], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
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 1.6:\\
\;\;\;\;{\left(\frac{\ell \cdot \sqrt{2}}{k\_m \cdot \sin k\_m} \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(t\_3 \cdot \frac{t\_m}{{\left(\left(t\_m \cdot {\left(\sqrt[3]{\ell}\right)}^{-2}\right) \cdot t\_2\right)}^{2}}\right) \cdot \left(t\_3 \cdot {\ell}^{0.6666666666666666}\right)}{t\_2}\\
\end{array}
\end{array}
\end{array}
if k < 1.6000000000000001Initial program 36.9%
*-commutative36.9%
associate-/r*36.9%
Simplified42.3%
add-sqr-sqrt26.2%
sqrt-div19.7%
sqrt-div19.7%
Applied egg-rr30.3%
unpow230.3%
associate-/r*30.3%
associate-/r/31.3%
associate-/r/31.3%
*-commutative31.3%
Simplified31.3%
Taylor expanded in t around 0 47.8%
if 1.6000000000000001 < k Initial program 31.0%
*-commutative31.0%
associate-/r*31.0%
Simplified40.1%
add-sqr-sqrt40.1%
add-cube-cbrt40.0%
times-frac40.0%
Applied egg-rr77.3%
associate-/r/77.4%
associate-/r*77.4%
associate-/r/77.4%
Simplified77.4%
*-commutative77.4%
cbrt-prod77.5%
Applied egg-rr77.5%
associate-*r/77.4%
Applied egg-rr79.4%
associate-/r*79.3%
pow179.3%
pow179.3%
pow-div79.3%
metadata-eval79.3%
metadata-eval79.3%
pow-flip79.4%
metadata-eval79.4%
pow279.4%
pow1/341.8%
pow1/341.5%
pow-prod-up41.5%
metadata-eval41.5%
Applied egg-rr41.5%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(let* ((t_2 (* l (sqrt 2.0))))
(*
t_s
(if (<= (* l l) 1e-295)
(pow (* (/ t_2 (pow k_m 2.0)) (sqrt (/ 1.0 t_m))) 2.0)
(if (<= (* l l) 2e+236)
(*
(/ 2.0 (pow k_m 2.0))
(/ (pow l 2.0) (* (sin k_m) (* t_m (tan k_m)))))
(pow (* (/ t_2 (* k_m (sin k_m))) (sqrt (/ (cos k_m) t_m))) 2.0))))))k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double t_2 = l * sqrt(2.0);
double tmp;
if ((l * l) <= 1e-295) {
tmp = pow(((t_2 / pow(k_m, 2.0)) * sqrt((1.0 / t_m))), 2.0);
} else if ((l * l) <= 2e+236) {
tmp = (2.0 / pow(k_m, 2.0)) * (pow(l, 2.0) / (sin(k_m) * (t_m * tan(k_m))));
} else {
tmp = pow(((t_2 / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))), 2.0);
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: t_2
real(8) :: tmp
t_2 = l * sqrt(2.0d0)
if ((l * l) <= 1d-295) then
tmp = ((t_2 / (k_m ** 2.0d0)) * sqrt((1.0d0 / t_m))) ** 2.0d0
else if ((l * l) <= 2d+236) then
tmp = (2.0d0 / (k_m ** 2.0d0)) * ((l ** 2.0d0) / (sin(k_m) * (t_m * tan(k_m))))
else
tmp = ((t_2 / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))) ** 2.0d0
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double t_2 = l * Math.sqrt(2.0);
double tmp;
if ((l * l) <= 1e-295) {
tmp = Math.pow(((t_2 / Math.pow(k_m, 2.0)) * Math.sqrt((1.0 / t_m))), 2.0);
} else if ((l * l) <= 2e+236) {
tmp = (2.0 / Math.pow(k_m, 2.0)) * (Math.pow(l, 2.0) / (Math.sin(k_m) * (t_m * Math.tan(k_m))));
} else {
tmp = Math.pow(((t_2 / (k_m * Math.sin(k_m))) * Math.sqrt((Math.cos(k_m) / t_m))), 2.0);
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): t_2 = l * math.sqrt(2.0) tmp = 0 if (l * l) <= 1e-295: tmp = math.pow(((t_2 / math.pow(k_m, 2.0)) * math.sqrt((1.0 / t_m))), 2.0) elif (l * l) <= 2e+236: tmp = (2.0 / math.pow(k_m, 2.0)) * (math.pow(l, 2.0) / (math.sin(k_m) * (t_m * math.tan(k_m)))) else: tmp = math.pow(((t_2 / (k_m * math.sin(k_m))) * math.sqrt((math.cos(k_m) / t_m))), 2.0) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) t_2 = Float64(l * sqrt(2.0)) tmp = 0.0 if (Float64(l * l) <= 1e-295) tmp = Float64(Float64(t_2 / (k_m ^ 2.0)) * sqrt(Float64(1.0 / t_m))) ^ 2.0; elseif (Float64(l * l) <= 2e+236) tmp = Float64(Float64(2.0 / (k_m ^ 2.0)) * Float64((l ^ 2.0) / Float64(sin(k_m) * Float64(t_m * tan(k_m))))); else tmp = Float64(Float64(t_2 / Float64(k_m * sin(k_m))) * sqrt(Float64(cos(k_m) / t_m))) ^ 2.0; end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) t_2 = l * sqrt(2.0); tmp = 0.0; if ((l * l) <= 1e-295) tmp = ((t_2 / (k_m ^ 2.0)) * sqrt((1.0 / t_m))) ^ 2.0; elseif ((l * l) <= 2e+236) tmp = (2.0 / (k_m ^ 2.0)) * ((l ^ 2.0) / (sin(k_m) * (t_m * tan(k_m)))); else tmp = ((t_2 / (k_m * sin(k_m))) * sqrt((cos(k_m) / t_m))) ^ 2.0; end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := Block[{t$95$2 = N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[N[(l * l), $MachinePrecision], 1e-295], N[Power[N[(N[(t$95$2 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], If[LessEqual[N[(l * l), $MachinePrecision], 2e+236], N[(N[(2.0 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[l, 2.0], $MachinePrecision] / N[(N[Sin[k$95$m], $MachinePrecision] * N[(t$95$m * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Power[N[(N[(t$95$2 / N[(k$95$m * 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}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
\begin{array}{l}
t_2 := \ell \cdot \sqrt{2}\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;\ell \cdot \ell \leq 10^{-295}:\\
\;\;\;\;{\left(\frac{t\_2}{{k\_m}^{2}} \cdot \sqrt{\frac{1}{t\_m}}\right)}^{2}\\
\mathbf{elif}\;\ell \cdot \ell \leq 2 \cdot 10^{+236}:\\
\;\;\;\;\frac{2}{{k\_m}^{2}} \cdot \frac{{\ell}^{2}}{\sin k\_m \cdot \left(t\_m \cdot \tan k\_m\right)}\\
\mathbf{else}:\\
\;\;\;\;{\left(\frac{t\_2}{k\_m \cdot \sin k\_m} \cdot \sqrt{\frac{\cos k\_m}{t\_m}}\right)}^{2}\\
\end{array}
\end{array}
\end{array}
if (*.f64 l l) < 1.00000000000000006e-295Initial program 14.7%
*-commutative14.7%
associate-/r*14.7%
Simplified28.1%
add-sqr-sqrt28.0%
sqrt-div13.3%
sqrt-div13.3%
Applied egg-rr15.9%
unpow215.9%
associate-/r*15.9%
associate-/r/18.4%
associate-/r/18.4%
*-commutative18.4%
Simplified18.4%
Taylor expanded in k around 0 34.3%
*-commutative34.3%
Simplified34.3%
if 1.00000000000000006e-295 < (*.f64 l l) < 2.00000000000000011e236Initial program 43.1%
Simplified52.7%
add-log-exp27.6%
exp-prod37.1%
associate-*r*37.1%
*-commutative37.1%
Applied egg-rr37.1%
Taylor expanded in k around inf 90.5%
associate-*r*90.4%
Simplified90.4%
associate-*l/90.5%
pow290.5%
*-commutative90.5%
Applied egg-rr90.5%
times-frac92.3%
associate-*r*92.2%
Simplified92.2%
if 2.00000000000000011e236 < (*.f64 l l) Initial program 45.2%
*-commutative45.2%
associate-/r*45.2%
Simplified45.3%
add-sqr-sqrt22.0%
sqrt-div22.0%
sqrt-div22.0%
Applied egg-rr28.3%
unpow228.3%
associate-/r*28.3%
associate-/r/28.3%
associate-/r/28.3%
*-commutative28.3%
Simplified28.3%
Taylor expanded in t around 0 49.8%
Final simplification61.4%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= k_m 1.06e-14)
(pow (* (/ (* l (sqrt 2.0)) (pow k_m 2.0)) (sqrt (/ 1.0 t_m))) 2.0)
(* (/ (/ 2.0 (pow k_m 2.0)) (* (tan k_m) (* (sin k_m) t_m))) (* l 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, double k_m) {
double tmp;
if (k_m <= 1.06e-14) {
tmp = pow((((l * sqrt(2.0)) / pow(k_m, 2.0)) * sqrt((1.0 / t_m))), 2.0);
} else {
tmp = ((2.0 / pow(k_m, 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l);
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 1.06d-14) then
tmp = (((l * sqrt(2.0d0)) / (k_m ** 2.0d0)) * sqrt((1.0d0 / t_m))) ** 2.0d0
else
tmp = ((2.0d0 / (k_m ** 2.0d0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l)
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 1.06e-14) {
tmp = Math.pow((((l * Math.sqrt(2.0)) / Math.pow(k_m, 2.0)) * Math.sqrt((1.0 / t_m))), 2.0);
} else {
tmp = ((2.0 / Math.pow(k_m, 2.0)) / (Math.tan(k_m) * (Math.sin(k_m) * t_m))) * (l * l);
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if k_m <= 1.06e-14: tmp = math.pow((((l * math.sqrt(2.0)) / math.pow(k_m, 2.0)) * math.sqrt((1.0 / t_m))), 2.0) else: tmp = ((2.0 / math.pow(k_m, 2.0)) / (math.tan(k_m) * (math.sin(k_m) * t_m))) * (l * l) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (k_m <= 1.06e-14) tmp = Float64(Float64(Float64(l * sqrt(2.0)) / (k_m ^ 2.0)) * sqrt(Float64(1.0 / t_m))) ^ 2.0; else tmp = Float64(Float64(Float64(2.0 / (k_m ^ 2.0)) / Float64(tan(k_m) * Float64(sin(k_m) * t_m))) * Float64(l * l)); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if (k_m <= 1.06e-14) tmp = (((l * sqrt(2.0)) / (k_m ^ 2.0)) * sqrt((1.0 / t_m))) ^ 2.0; else tmp = ((2.0 / (k_m ^ 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l); end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 1.06e-14], N[Power[N[(N[(N[(l * 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[(N[(2.0 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 1.06 \cdot 10^{-14}:\\
\;\;\;\;{\left(\frac{\ell \cdot \sqrt{2}}{{k\_m}^{2}} \cdot \sqrt{\frac{1}{t\_m}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{{k\_m}^{2}}}{\tan k\_m \cdot \left(\sin k\_m \cdot t\_m\right)} \cdot \left(\ell \cdot \ell\right)\\
\end{array}
\end{array}
if k < 1.06e-14Initial program 37.6%
*-commutative37.6%
associate-/r*37.6%
Simplified42.6%
add-sqr-sqrt26.7%
sqrt-div20.1%
sqrt-div20.1%
Applied egg-rr30.4%
unpow230.4%
associate-/r*30.4%
associate-/r/31.4%
associate-/r/31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in k around 0 42.2%
*-commutative42.2%
Simplified42.2%
if 1.06e-14 < k Initial program 29.4%
Simplified40.7%
add-log-exp28.6%
exp-prod26.2%
associate-*r*26.2%
*-commutative26.2%
Applied egg-rr26.2%
Taylor expanded in k around inf 68.8%
associate-*r*68.7%
Simplified68.7%
*-un-lft-identity68.7%
associate-/r*70.0%
*-commutative70.0%
Applied egg-rr70.0%
Final simplification50.0%
k_m = (fabs.f64 k)
t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s t_m l k_m)
:precision binary64
(*
t_s
(if (<= k_m 1.4e-14)
(pow (* (* l (sqrt 2.0)) (/ (sqrt (/ 1.0 t_m)) (pow k_m 2.0))) 2.0)
(* (/ (/ 2.0 (pow k_m 2.0)) (* (tan k_m) (* (sin k_m) t_m))) (* l 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, double k_m) {
double tmp;
if (k_m <= 1.4e-14) {
tmp = pow(((l * sqrt(2.0)) * (sqrt((1.0 / t_m)) / pow(k_m, 2.0))), 2.0);
} else {
tmp = ((2.0 / pow(k_m, 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l);
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 1.4d-14) then
tmp = ((l * sqrt(2.0d0)) * (sqrt((1.0d0 / t_m)) / (k_m ** 2.0d0))) ** 2.0d0
else
tmp = ((2.0d0 / (k_m ** 2.0d0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l)
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 1.4e-14) {
tmp = Math.pow(((l * Math.sqrt(2.0)) * (Math.sqrt((1.0 / t_m)) / Math.pow(k_m, 2.0))), 2.0);
} else {
tmp = ((2.0 / Math.pow(k_m, 2.0)) / (Math.tan(k_m) * (Math.sin(k_m) * t_m))) * (l * l);
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if k_m <= 1.4e-14: tmp = math.pow(((l * math.sqrt(2.0)) * (math.sqrt((1.0 / t_m)) / math.pow(k_m, 2.0))), 2.0) else: tmp = ((2.0 / math.pow(k_m, 2.0)) / (math.tan(k_m) * (math.sin(k_m) * t_m))) * (l * l) return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (k_m <= 1.4e-14) tmp = Float64(Float64(l * sqrt(2.0)) * Float64(sqrt(Float64(1.0 / t_m)) / (k_m ^ 2.0))) ^ 2.0; else tmp = Float64(Float64(Float64(2.0 / (k_m ^ 2.0)) / Float64(tan(k_m) * Float64(sin(k_m) * t_m))) * Float64(l * l)); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if (k_m <= 1.4e-14) tmp = ((l * sqrt(2.0)) * (sqrt((1.0 / t_m)) / (k_m ^ 2.0))) ^ 2.0; else tmp = ((2.0 / (k_m ^ 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l); end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 1.4e-14], N[Power[N[(N[(l * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[N[(1.0 / t$95$m), $MachinePrecision]], $MachinePrecision] / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], N[(N[(N[(2.0 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;{\left(\left(\ell \cdot \sqrt{2}\right) \cdot \frac{\sqrt{\frac{1}{t\_m}}}{{k\_m}^{2}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2}{{k\_m}^{2}}}{\tan k\_m \cdot \left(\sin k\_m \cdot t\_m\right)} \cdot \left(\ell \cdot \ell\right)\\
\end{array}
\end{array}
if k < 1.4e-14Initial program 37.6%
*-commutative37.6%
associate-/r*37.6%
Simplified42.6%
add-sqr-sqrt26.7%
sqrt-div20.1%
sqrt-div20.1%
Applied egg-rr30.4%
unpow230.4%
associate-/r*30.4%
associate-/r/31.4%
associate-/r/31.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in k around 0 42.2%
associate-*l/41.3%
associate-/l*42.2%
*-commutative42.2%
Simplified42.2%
if 1.4e-14 < k Initial program 29.4%
Simplified40.7%
add-log-exp28.6%
exp-prod26.2%
associate-*r*26.2%
*-commutative26.2%
Applied egg-rr26.2%
Taylor expanded in k around inf 68.8%
associate-*r*68.7%
Simplified68.7%
*-un-lft-identity68.7%
associate-/r*70.0%
*-commutative70.0%
Applied egg-rr70.0%
Final simplification50.0%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (/ (/ 2.0 (pow k_m 2.0)) (* (tan k_m) (* (sin k_m) t_m))) (* l 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, double k_m) {
return t_s * (((2.0 / pow(k_m, 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * (((2.0d0 / (k_m ** 2.0d0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * (((2.0 / Math.pow(k_m, 2.0)) / (Math.tan(k_m) * (Math.sin(k_m) * t_m))) * (l * 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, k_m): return t_s * (((2.0 / math.pow(k_m, 2.0)) / (math.tan(k_m) * (math.sin(k_m) * t_m))) * (l * l))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(Float64(2.0 / (k_m ^ 2.0)) / Float64(tan(k_m) * Float64(sin(k_m) * t_m))) * Float64(l * l))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * (((2.0 / (k_m ^ 2.0)) / (tan(k_m) * (sin(k_m) * t_m))) * (l * l)); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(N[(2.0 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\frac{\frac{2}{{k\_m}^{2}}}{\tan k\_m \cdot \left(\sin k\_m \cdot t\_m\right)} \cdot \left(\ell \cdot \ell\right)\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-log-exp25.8%
exp-prod32.7%
associate-*r*32.7%
*-commutative32.7%
Applied egg-rr32.7%
Taylor expanded in k around inf 74.4%
associate-*r*74.4%
Simplified74.4%
*-un-lft-identity74.4%
associate-/r*74.7%
*-commutative74.7%
Applied egg-rr74.7%
Final simplification74.7%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ (/ 2.0 (pow k_m 2.0)) (* (sin k_m) (* t_m (tan k_m)))))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * ((2.0 / pow(k_m, 2.0)) / (sin(k_m) * (t_m * tan(k_m)))));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * ((2.0d0 / (k_m ** 2.0d0)) / (sin(k_m) * (t_m * tan(k_m)))))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * ((2.0 / Math.pow(k_m, 2.0)) / (Math.sin(k_m) * (t_m * Math.tan(k_m)))));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * ((2.0 / math.pow(k_m, 2.0)) / (math.sin(k_m) * (t_m * math.tan(k_m)))))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(Float64(2.0 / (k_m ^ 2.0)) / Float64(sin(k_m) * Float64(t_m * tan(k_m)))))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * ((2.0 / (k_m ^ 2.0)) / (sin(k_m) * (t_m * tan(k_m))))); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(N[(2.0 / N[Power[k$95$m, 2.0], $MachinePrecision]), $MachinePrecision] / N[(N[Sin[k$95$m], $MachinePrecision] * N[(t$95$m * N[Tan[k$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{\frac{2}{{k\_m}^{2}}}{\sin k\_m \cdot \left(t\_m \cdot \tan k\_m\right)}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-log-exp25.8%
exp-prod32.7%
associate-*r*32.7%
*-commutative32.7%
Applied egg-rr32.7%
Taylor expanded in k around inf 74.4%
associate-*r*74.4%
Simplified74.4%
div-inv74.4%
*-commutative74.4%
Applied egg-rr74.4%
associate-*r/74.4%
metadata-eval74.4%
associate-/r*74.7%
associate-*r*74.7%
Simplified74.7%
Final simplification74.7%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ 2.0 (* (* (sin k_m) (tan k_m)) (* t_m (pow k_m 2.0)))))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / ((sin(k_m) * tan(k_m)) * (t_m * pow(k_m, 2.0)))));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * (2.0d0 / ((sin(k_m) * tan(k_m)) * (t_m * (k_m ** 2.0d0)))))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / ((Math.sin(k_m) * Math.tan(k_m)) * (t_m * Math.pow(k_m, 2.0)))));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * (2.0 / ((math.sin(k_m) * math.tan(k_m)) * (t_m * math.pow(k_m, 2.0)))))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(2.0 / Float64(Float64(sin(k_m) * tan(k_m)) * Float64(t_m * (k_m ^ 2.0)))))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * (2.0 / ((sin(k_m) * tan(k_m)) * (t_m * (k_m ^ 2.0))))); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $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}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{2}{\left(\sin k\_m \cdot \tan k\_m\right) \cdot \left(t\_m \cdot {k\_m}^{2}\right)}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-log-exp25.8%
exp-prod32.7%
associate-*r*32.7%
*-commutative32.7%
Applied egg-rr32.7%
Taylor expanded in k around inf 74.4%
associate-*r*74.4%
Simplified74.4%
Final simplification74.4%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ 2.0 (* (* k_m k_m) (* (tan k_m) (* (sin k_m) t_m)))))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / ((k_m * k_m) * (tan(k_m) * (sin(k_m) * t_m)))));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * (2.0d0 / ((k_m * k_m) * (tan(k_m) * (sin(k_m) * t_m)))))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / ((k_m * k_m) * (Math.tan(k_m) * (Math.sin(k_m) * t_m)))));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * (2.0 / ((k_m * k_m) * (math.tan(k_m) * (math.sin(k_m) * t_m)))))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(2.0 / Float64(Float64(k_m * k_m) * Float64(tan(k_m) * Float64(sin(k_m) * t_m)))))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * (2.0 / ((k_m * k_m) * (tan(k_m) * (sin(k_m) * t_m))))); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[(k$95$m * k$95$m), $MachinePrecision] * N[(N[Tan[k$95$m], $MachinePrecision] * N[(N[Sin[k$95$m], $MachinePrecision] * t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{2}{\left(k\_m \cdot k\_m\right) \cdot \left(\tan k\_m \cdot \left(\sin k\_m \cdot t\_m\right)\right)}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-log-exp25.8%
exp-prod32.7%
associate-*r*32.7%
*-commutative32.7%
Applied egg-rr32.7%
Taylor expanded in k around inf 74.4%
associate-*r*74.4%
Simplified74.4%
unpow274.4%
Applied egg-rr74.4%
Final simplification74.4%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ 2.0 (* (pow k_m 2.0) (* k_m (* (sin k_m) t_m)))))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / (pow(k_m, 2.0) * (k_m * (sin(k_m) * t_m)))));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * (2.0d0 / ((k_m ** 2.0d0) * (k_m * (sin(k_m) * t_m)))))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / (Math.pow(k_m, 2.0) * (k_m * (Math.sin(k_m) * t_m)))));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * (2.0 / (math.pow(k_m, 2.0) * (k_m * (math.sin(k_m) * t_m)))))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(2.0 / Float64((k_m ^ 2.0) * Float64(k_m * Float64(sin(k_m) * t_m)))))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * (2.0 / ((k_m ^ 2.0) * (k_m * (sin(k_m) * t_m))))); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(k$95$m * N[(N[Sin[k$95$m], $MachinePrecision] * t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{2}{{k\_m}^{2} \cdot \left(k\_m \cdot \left(\sin k\_m \cdot t\_m\right)\right)}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-log-exp25.8%
exp-prod32.7%
associate-*r*32.7%
*-commutative32.7%
Applied egg-rr32.7%
Taylor expanded in k around inf 74.4%
associate-*r*74.4%
Simplified74.4%
Taylor expanded in k around 0 64.8%
Final simplification64.8%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ 2.0 (* (pow k_m 2.0) (* (tan k_m) (* k_m t_m)))))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / (pow(k_m, 2.0) * (tan(k_m) * (k_m * t_m)))));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * (2.0d0 / ((k_m ** 2.0d0) * (tan(k_m) * (k_m * t_m)))))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / (Math.pow(k_m, 2.0) * (Math.tan(k_m) * (k_m * t_m)))));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * (2.0 / (math.pow(k_m, 2.0) * (math.tan(k_m) * (k_m * t_m)))))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(2.0 / Float64((k_m ^ 2.0) * Float64(tan(k_m) * Float64(k_m * t_m)))))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * (2.0 / ((k_m ^ 2.0) * (tan(k_m) * (k_m * t_m))))); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(N[Power[k$95$m, 2.0], $MachinePrecision] * N[(N[Tan[k$95$m], $MachinePrecision] * N[(k$95$m * t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{2}{{k\_m}^{2} \cdot \left(\tan k\_m \cdot \left(k\_m \cdot t\_m\right)\right)}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-log-exp25.8%
exp-prod32.7%
associate-*r*32.7%
*-commutative32.7%
Applied egg-rr32.7%
Taylor expanded in k around inf 74.4%
associate-*r*74.4%
Simplified74.4%
Taylor expanded in k around 0 64.5%
Final simplification64.5%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* 2.0 (/ (/ (pow l 2.0) (pow k_m 4.0)) t_m))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * (2.0 * ((pow(l, 2.0) / pow(k_m, 4.0)) / t_m));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * (2.0d0 * (((l ** 2.0d0) / (k_m ** 4.0d0)) / t_m))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * (2.0 * ((Math.pow(l, 2.0) / Math.pow(k_m, 4.0)) / t_m));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * (2.0 * ((math.pow(l, 2.0) / math.pow(k_m, 4.0)) / t_m))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(2.0 * Float64(Float64((l ^ 2.0) / (k_m ^ 4.0)) / t_m))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * (2.0 * (((l ^ 2.0) / (k_m ^ 4.0)) / t_m)); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(2 \cdot \frac{\frac{{\ell}^{2}}{{k\_m}^{4}}}{t\_m}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
Taylor expanded in k around 0 62.9%
expm1-log1p-u48.4%
expm1-undefine32.1%
*-commutative32.1%
Applied egg-rr32.1%
expm1-define48.4%
*-commutative48.4%
Simplified48.4%
Taylor expanded in k around 0 62.9%
associate-/r*63.2%
Simplified63.2%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ (/ 2.0 (pow k_m 4.0)) t_m))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * ((2.0 / pow(k_m, 4.0)) / t_m));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * ((2.0d0 / (k_m ** 4.0d0)) / t_m))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * ((2.0 / Math.pow(k_m, 4.0)) / t_m));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * ((2.0 / math.pow(k_m, 4.0)) / t_m))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(Float64(2.0 / (k_m ^ 4.0)) / t_m))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * ((2.0 / (k_m ^ 4.0)) / t_m)); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(N[(2.0 / N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision] / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{\frac{2}{{k\_m}^{4}}}{t\_m}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-cube-cbrt43.7%
pow343.7%
cbrt-prod43.7%
rem-cbrt-cube61.2%
associate-*r*61.2%
*-commutative61.2%
Applied egg-rr61.2%
Taylor expanded in k around 0 62.9%
associate-/r*62.9%
Simplified62.9%
Final simplification62.9%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) (/ 2.0 (* t_m (pow k_m 4.0))))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / (t_m * pow(k_m, 4.0))));
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * (2.0d0 / (t_m * (k_m ** 4.0d0))))
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * (2.0 / (t_m * Math.pow(k_m, 4.0))));
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * (2.0 / (t_m * math.pow(k_m, 4.0))))
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * Float64(2.0 / Float64(t_m * (k_m ^ 4.0))))) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * (2.0 / (t_m * (k_m ^ 4.0)))); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * N[(2.0 / N[(t$95$m * N[Power[k$95$m, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot \frac{2}{t\_m \cdot {k\_m}^{4}}\right)
\end{array}
Initial program 35.3%
Simplified43.7%
Taylor expanded in k around 0 62.9%
Final simplification62.9%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (if (<= k_m 1.6e-29) (* (* l l) (/ 2.0 0.0)) (* (* l l) 0.0))))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 1.6e-29) {
tmp = (l * l) * (2.0 / 0.0);
} else {
tmp = (l * l) * 0.0;
}
return t_s * tmp;
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
real(8) :: tmp
if (k_m <= 1.6d-29) then
tmp = (l * l) * (2.0d0 / 0.0d0)
else
tmp = (l * l) * 0.0d0
end if
code = t_s * tmp
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
double tmp;
if (k_m <= 1.6e-29) {
tmp = (l * l) * (2.0 / 0.0);
} else {
tmp = (l * l) * 0.0;
}
return t_s * tmp;
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): tmp = 0 if k_m <= 1.6e-29: tmp = (l * l) * (2.0 / 0.0) else: tmp = (l * l) * 0.0 return t_s * tmp
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) tmp = 0.0 if (k_m <= 1.6e-29) tmp = Float64(Float64(l * l) * Float64(2.0 / 0.0)); else tmp = Float64(Float64(l * l) * 0.0); end return Float64(t_s * tmp) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp_2 = code(t_s, t_m, l, k_m) tmp = 0.0; if (k_m <= 1.6e-29) tmp = (l * l) * (2.0 / 0.0); else tmp = (l * l) * 0.0; end tmp_2 = t_s * tmp; end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * If[LessEqual[k$95$m, 1.6e-29], N[(N[(l * l), $MachinePrecision] * N[(2.0 / 0.0), $MachinePrecision]), $MachinePrecision], N[(N[(l * l), $MachinePrecision] * 0.0), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \begin{array}{l}
\mathbf{if}\;k\_m \leq 1.6 \cdot 10^{-29}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot \frac{2}{0}\\
\mathbf{else}:\\
\;\;\;\;\left(\ell \cdot \ell\right) \cdot 0\\
\end{array}
\end{array}
if k < 1.6e-29Initial program 37.9%
Simplified44.8%
add-log-exp24.7%
exp-prod35.4%
associate-*r*35.4%
*-commutative35.4%
Applied egg-rr35.4%
Taylor expanded in t around 0 27.2%
metadata-eval27.2%
Applied egg-rr27.2%
if 1.6e-29 < k Initial program 29.1%
Simplified41.3%
add-log-exp28.5%
exp-prod26.2%
associate-*r*26.2%
*-commutative26.2%
Applied egg-rr26.2%
Taylor expanded in t around 0 5.1%
metadata-eval5.1%
Applied egg-rr5.1%
clear-num5.1%
metadata-eval5.1%
inv-pow5.1%
Applied egg-rr5.1%
pow-base-042.3%
Simplified42.3%
Final simplification31.7%
k_m = (fabs.f64 k) t\_m = (fabs.f64 t) t\_s = (copysign.f64 #s(literal 1 binary64) t) (FPCore (t_s t_m l k_m) :precision binary64 (* t_s (* (* l l) 0.0)))
k_m = fabs(k);
t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * 0.0);
}
k_m = abs(k)
t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k_m)
real(8), intent (in) :: t_s
real(8), intent (in) :: t_m
real(8), intent (in) :: l
real(8), intent (in) :: k_m
code = t_s * ((l * l) * 0.0d0)
end function
k_m = Math.abs(k);
t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k_m) {
return t_s * ((l * l) * 0.0);
}
k_m = math.fabs(k) t\_m = math.fabs(t) t\_s = math.copysign(1.0, t) def code(t_s, t_m, l, k_m): return t_s * ((l * l) * 0.0)
k_m = abs(k) t\_m = abs(t) t\_s = copysign(1.0, t) function code(t_s, t_m, l, k_m) return Float64(t_s * Float64(Float64(l * l) * 0.0)) end
k_m = abs(k); t\_m = abs(t); t\_s = sign(t) * abs(1.0); function tmp = code(t_s, t_m, l, k_m) tmp = t_s * ((l * l) * 0.0); end
k_m = N[Abs[k], $MachinePrecision]
t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k$95$m_] := N[(t$95$s * N[(N[(l * l), $MachinePrecision] * 0.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k_m = \left|k\right|
\\
t\_m = \left|t\right|
\\
t\_s = \mathsf{copysign}\left(1, t\right)
\\
t\_s \cdot \left(\left(\ell \cdot \ell\right) \cdot 0\right)
\end{array}
Initial program 35.3%
Simplified43.7%
add-log-exp25.8%
exp-prod32.7%
associate-*r*32.7%
*-commutative32.7%
Applied egg-rr32.7%
Taylor expanded in t around 0 20.7%
metadata-eval20.7%
Applied egg-rr20.7%
clear-num20.7%
metadata-eval20.7%
inv-pow20.7%
Applied egg-rr20.7%
pow-base-027.2%
Simplified27.2%
Final simplification27.2%
herbie shell --seed 2024116
(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))))