
(FPCore (F l) :precision binary64 (- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))
double code(double F, double l) {
return (((double) M_PI) * l) - ((1.0 / (F * F)) * tan((((double) M_PI) * l)));
}
public static double code(double F, double l) {
return (Math.PI * l) - ((1.0 / (F * F)) * Math.tan((Math.PI * l)));
}
def code(F, l): return (math.pi * l) - ((1.0 / (F * F)) * math.tan((math.pi * l)))
function code(F, l) return Float64(Float64(pi * l) - Float64(Float64(1.0 / Float64(F * F)) * tan(Float64(pi * l)))) end
function tmp = code(F, l) tmp = (pi * l) - ((1.0 / (F * F)) * tan((pi * l))); end
code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(1.0 / N[(F * F), $MachinePrecision]), $MachinePrecision] * N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\pi \cdot \ell - \frac{1}{F \cdot F} \cdot \tan \left(\pi \cdot \ell\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (F l) :precision binary64 (- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))
double code(double F, double l) {
return (((double) M_PI) * l) - ((1.0 / (F * F)) * tan((((double) M_PI) * l)));
}
public static double code(double F, double l) {
return (Math.PI * l) - ((1.0 / (F * F)) * Math.tan((Math.PI * l)));
}
def code(F, l): return (math.pi * l) - ((1.0 / (F * F)) * math.tan((math.pi * l)))
function code(F, l) return Float64(Float64(pi * l) - Float64(Float64(1.0 / Float64(F * F)) * tan(Float64(pi * l)))) end
function tmp = code(F, l) tmp = (pi * l) - ((1.0 / (F * F)) * tan((pi * l))); end
code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(1.0 / N[(F * F), $MachinePrecision]), $MachinePrecision] * N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\pi \cdot \ell - \frac{1}{F \cdot F} \cdot \tan \left(\pi \cdot \ell\right)
\end{array}
F_m = (fabs.f64 F)
(FPCore (F_m l)
:precision binary64
(let* ((t_0 (* (pow PI 3.0) 0.3333333333333333))
(t_1 (/ (pow F_m 2.0) (pow PI 2.0)))
(t_2 (* 0.008333333333333333 (pow PI 5.0)))
(t_3 (/ (pow F_m 2.0) (pow PI 3.0)))
(t_4
(fma
-0.5
(* (pow PI 3.0) (* (pow PI 2.0) 0.3333333333333333))
(* (pow PI 5.0) 0.041666666666666664)))
(t_5 (- t_4 t_2))
(t_6 (+ (* t_3 (pow t_0 2.0)) (* t_1 t_5))))
(if (<= F_m 1.62e-161)
(- (* PI l) (/ (/ (tan (* l (pow (sqrt PI) 2.0))) F_m) F_m))
(if (<= F_m 5e-52)
(-
(* PI l)
(/
1.0
(+
(-
(-
(/ (pow F_m 2.0) (* PI l))
(* t_1 (* (pow PI 3.0) (* l 0.3333333333333333))))
(*
(pow l 5.0)
(+
(+
(*
t_1
(-
(* -0.0001984126984126984 (pow PI 7.0))
(fma
(* (pow PI 2.0) -0.5)
(- t_2 t_4)
(fma
0.041666666666666664
(* (pow PI 3.0) (* 0.3333333333333333 (pow PI 4.0)))
(* (pow PI 7.0) -0.001388888888888889)))))
(* t_3 (* t_0 t_5)))
(* t_0 (/ t_6 PI)))))
(* (pow l 3.0) t_6))))
(- (* PI l) (/ (/ (tan (* l (cbrt (pow PI 3.0)))) F_m) F_m))))))F_m = fabs(F);
double code(double F_m, double l) {
double t_0 = pow(((double) M_PI), 3.0) * 0.3333333333333333;
double t_1 = pow(F_m, 2.0) / pow(((double) M_PI), 2.0);
double t_2 = 0.008333333333333333 * pow(((double) M_PI), 5.0);
double t_3 = pow(F_m, 2.0) / pow(((double) M_PI), 3.0);
double t_4 = fma(-0.5, (pow(((double) M_PI), 3.0) * (pow(((double) M_PI), 2.0) * 0.3333333333333333)), (pow(((double) M_PI), 5.0) * 0.041666666666666664));
double t_5 = t_4 - t_2;
double t_6 = (t_3 * pow(t_0, 2.0)) + (t_1 * t_5);
double tmp;
if (F_m <= 1.62e-161) {
tmp = (((double) M_PI) * l) - ((tan((l * pow(sqrt(((double) M_PI)), 2.0))) / F_m) / F_m);
} else if (F_m <= 5e-52) {
tmp = (((double) M_PI) * l) - (1.0 / ((((pow(F_m, 2.0) / (((double) M_PI) * l)) - (t_1 * (pow(((double) M_PI), 3.0) * (l * 0.3333333333333333)))) - (pow(l, 5.0) * (((t_1 * ((-0.0001984126984126984 * pow(((double) M_PI), 7.0)) - fma((pow(((double) M_PI), 2.0) * -0.5), (t_2 - t_4), fma(0.041666666666666664, (pow(((double) M_PI), 3.0) * (0.3333333333333333 * pow(((double) M_PI), 4.0))), (pow(((double) M_PI), 7.0) * -0.001388888888888889))))) + (t_3 * (t_0 * t_5))) + (t_0 * (t_6 / ((double) M_PI)))))) + (pow(l, 3.0) * t_6)));
} else {
tmp = (((double) M_PI) * l) - ((tan((l * cbrt(pow(((double) M_PI), 3.0)))) / F_m) / F_m);
}
return tmp;
}
F_m = abs(F) function code(F_m, l) t_0 = Float64((pi ^ 3.0) * 0.3333333333333333) t_1 = Float64((F_m ^ 2.0) / (pi ^ 2.0)) t_2 = Float64(0.008333333333333333 * (pi ^ 5.0)) t_3 = Float64((F_m ^ 2.0) / (pi ^ 3.0)) t_4 = fma(-0.5, Float64((pi ^ 3.0) * Float64((pi ^ 2.0) * 0.3333333333333333)), Float64((pi ^ 5.0) * 0.041666666666666664)) t_5 = Float64(t_4 - t_2) t_6 = Float64(Float64(t_3 * (t_0 ^ 2.0)) + Float64(t_1 * t_5)) tmp = 0.0 if (F_m <= 1.62e-161) tmp = Float64(Float64(pi * l) - Float64(Float64(tan(Float64(l * (sqrt(pi) ^ 2.0))) / F_m) / F_m)); elseif (F_m <= 5e-52) tmp = Float64(Float64(pi * l) - Float64(1.0 / Float64(Float64(Float64(Float64((F_m ^ 2.0) / Float64(pi * l)) - Float64(t_1 * Float64((pi ^ 3.0) * Float64(l * 0.3333333333333333)))) - Float64((l ^ 5.0) * Float64(Float64(Float64(t_1 * Float64(Float64(-0.0001984126984126984 * (pi ^ 7.0)) - fma(Float64((pi ^ 2.0) * -0.5), Float64(t_2 - t_4), fma(0.041666666666666664, Float64((pi ^ 3.0) * Float64(0.3333333333333333 * (pi ^ 4.0))), Float64((pi ^ 7.0) * -0.001388888888888889))))) + Float64(t_3 * Float64(t_0 * t_5))) + Float64(t_0 * Float64(t_6 / pi))))) + Float64((l ^ 3.0) * t_6)))); else tmp = Float64(Float64(pi * l) - Float64(Float64(tan(Float64(l * cbrt((pi ^ 3.0)))) / F_m) / F_m)); end return tmp end
F_m = N[Abs[F], $MachinePrecision]
code[F$95$m_, l_] := Block[{t$95$0 = N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision]}, Block[{t$95$1 = N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[Power[Pi, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(0.008333333333333333 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[Power[Pi, 3.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(-0.5 * N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(N[Power[Pi, 2.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision] + N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.041666666666666664), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$4 - t$95$2), $MachinePrecision]}, Block[{t$95$6 = N[(N[(t$95$3 * N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision] + N[(t$95$1 * t$95$5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F$95$m, 1.62e-161], N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(l * N[Power[N[Sqrt[Pi], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision], If[LessEqual[F$95$m, 5e-52], N[(N[(Pi * l), $MachinePrecision] - N[(1.0 / N[(N[(N[(N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[Power[l, 5.0], $MachinePrecision] * N[(N[(N[(t$95$1 * N[(N[(-0.0001984126984126984 * N[Power[Pi, 7.0], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Power[Pi, 2.0], $MachinePrecision] * -0.5), $MachinePrecision] * N[(t$95$2 - t$95$4), $MachinePrecision] + N[(0.041666666666666664 * N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(0.3333333333333333 * N[Power[Pi, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[Pi, 7.0], $MachinePrecision] * -0.001388888888888889), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$3 * N[(t$95$0 * t$95$5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[(t$95$6 / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[l, 3.0], $MachinePrecision] * t$95$6), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(l * N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
F_m = \left|F\right|
\\
\begin{array}{l}
t_0 := {\pi}^{3} \cdot 0.3333333333333333\\
t_1 := \frac{{F_m}^{2}}{{\pi}^{2}}\\
t_2 := 0.008333333333333333 \cdot {\pi}^{5}\\
t_3 := \frac{{F_m}^{2}}{{\pi}^{3}}\\
t_4 := \mathsf{fma}\left(-0.5, {\pi}^{3} \cdot \left({\pi}^{2} \cdot 0.3333333333333333\right), {\pi}^{5} \cdot 0.041666666666666664\right)\\
t_5 := t_4 - t_2\\
t_6 := t_3 \cdot {t_0}^{2} + t_1 \cdot t_5\\
\mathbf{if}\;F_m \leq 1.62 \cdot 10^{-161}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\tan \left(\ell \cdot {\left(\sqrt{\pi}\right)}^{2}\right)}{F_m}}{F_m}\\
\mathbf{elif}\;F_m \leq 5 \cdot 10^{-52}:\\
\;\;\;\;\pi \cdot \ell - \frac{1}{\left(\left(\frac{{F_m}^{2}}{\pi \cdot \ell} - t_1 \cdot \left({\pi}^{3} \cdot \left(\ell \cdot 0.3333333333333333\right)\right)\right) - {\ell}^{5} \cdot \left(\left(t_1 \cdot \left(-0.0001984126984126984 \cdot {\pi}^{7} - \mathsf{fma}\left({\pi}^{2} \cdot -0.5, t_2 - t_4, \mathsf{fma}\left(0.041666666666666664, {\pi}^{3} \cdot \left(0.3333333333333333 \cdot {\pi}^{4}\right), {\pi}^{7} \cdot -0.001388888888888889\right)\right)\right) + t_3 \cdot \left(t_0 \cdot t_5\right)\right) + t_0 \cdot \frac{t_6}{\pi}\right)\right) + {\ell}^{3} \cdot t_6}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\tan \left(\ell \cdot \sqrt[3]{{\pi}^{3}}\right)}{F_m}}{F_m}\\
\end{array}
\end{array}
if F < 1.62e-161Initial program 65.5%
associate-*l/65.6%
*-un-lft-identity65.6%
associate-/r*74.8%
Applied egg-rr74.8%
add-sqr-sqrt74.9%
pow274.9%
Applied egg-rr74.9%
if 1.62e-161 < F < 5e-52Initial program 71.9%
associate-/r/71.8%
associate-/l*71.9%
clear-num71.9%
add-sqr-sqrt71.8%
sqrt-prod71.9%
sqr-neg71.9%
sqrt-unprod0.0%
add-sqr-sqrt29.7%
associate-/r*29.7%
clear-num29.7%
add-sqr-sqrt0.0%
sqrt-unprod71.8%
sqr-neg71.8%
sqrt-prod71.6%
add-sqr-sqrt71.8%
pow271.8%
Applied egg-rr71.8%
Taylor expanded in l around 0 91.3%
Simplified91.3%
if 5e-52 < F Initial program 99.6%
associate-*l/99.6%
*-un-lft-identity99.6%
associate-/r*99.6%
Applied egg-rr99.6%
add-cbrt-cube99.6%
pow399.6%
Applied egg-rr99.6%
Final simplification82.7%
F_m = (fabs.f64 F)
(FPCore (F_m l)
:precision binary64
(let* ((t_0 (/ (pow F_m 2.0) (pow PI 2.0))))
(if (<= F_m 1.1e-161)
(- (* PI l) (/ (/ (tan (* l (pow (sqrt PI) 2.0))) F_m) F_m))
(if (<= F_m 3e-52)
(+
(* PI l)
(/
-1.0
(+
(-
(/ (pow F_m 2.0) (* PI l))
(* t_0 (* (pow PI 3.0) (* l 0.3333333333333333))))
(*
(pow l 3.0)
(+
(*
(/ (pow F_m 2.0) (pow PI 3.0))
(pow (* (pow PI 3.0) 0.3333333333333333) 2.0))
(*
t_0
(-
(fma
-0.5
(* (pow PI 3.0) (* (pow PI 2.0) 0.3333333333333333))
(* (pow PI 5.0) 0.041666666666666664))
(* 0.008333333333333333 (pow PI 5.0)))))))))
(- (* PI l) (/ (/ (tan (* l (cbrt (pow PI 3.0)))) F_m) F_m))))))F_m = fabs(F);
double code(double F_m, double l) {
double t_0 = pow(F_m, 2.0) / pow(((double) M_PI), 2.0);
double tmp;
if (F_m <= 1.1e-161) {
tmp = (((double) M_PI) * l) - ((tan((l * pow(sqrt(((double) M_PI)), 2.0))) / F_m) / F_m);
} else if (F_m <= 3e-52) {
tmp = (((double) M_PI) * l) + (-1.0 / (((pow(F_m, 2.0) / (((double) M_PI) * l)) - (t_0 * (pow(((double) M_PI), 3.0) * (l * 0.3333333333333333)))) + (pow(l, 3.0) * (((pow(F_m, 2.0) / pow(((double) M_PI), 3.0)) * pow((pow(((double) M_PI), 3.0) * 0.3333333333333333), 2.0)) + (t_0 * (fma(-0.5, (pow(((double) M_PI), 3.0) * (pow(((double) M_PI), 2.0) * 0.3333333333333333)), (pow(((double) M_PI), 5.0) * 0.041666666666666664)) - (0.008333333333333333 * pow(((double) M_PI), 5.0))))))));
} else {
tmp = (((double) M_PI) * l) - ((tan((l * cbrt(pow(((double) M_PI), 3.0)))) / F_m) / F_m);
}
return tmp;
}
F_m = abs(F) function code(F_m, l) t_0 = Float64((F_m ^ 2.0) / (pi ^ 2.0)) tmp = 0.0 if (F_m <= 1.1e-161) tmp = Float64(Float64(pi * l) - Float64(Float64(tan(Float64(l * (sqrt(pi) ^ 2.0))) / F_m) / F_m)); elseif (F_m <= 3e-52) tmp = Float64(Float64(pi * l) + Float64(-1.0 / Float64(Float64(Float64((F_m ^ 2.0) / Float64(pi * l)) - Float64(t_0 * Float64((pi ^ 3.0) * Float64(l * 0.3333333333333333)))) + Float64((l ^ 3.0) * Float64(Float64(Float64((F_m ^ 2.0) / (pi ^ 3.0)) * (Float64((pi ^ 3.0) * 0.3333333333333333) ^ 2.0)) + Float64(t_0 * Float64(fma(-0.5, Float64((pi ^ 3.0) * Float64((pi ^ 2.0) * 0.3333333333333333)), Float64((pi ^ 5.0) * 0.041666666666666664)) - Float64(0.008333333333333333 * (pi ^ 5.0))))))))); else tmp = Float64(Float64(pi * l) - Float64(Float64(tan(Float64(l * cbrt((pi ^ 3.0)))) / F_m) / F_m)); end return tmp end
F_m = N[Abs[F], $MachinePrecision]
code[F$95$m_, l_] := Block[{t$95$0 = N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[Power[Pi, 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F$95$m, 1.1e-161], N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(l * N[Power[N[Sqrt[Pi], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision], If[LessEqual[F$95$m, 3e-52], N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(N[(N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(t$95$0 * N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Power[l, 3.0], $MachinePrecision] * N[(N[(N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[Power[Pi, 3.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[Power[Pi, 3.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[(N[(-0.5 * N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(N[Power[Pi, 2.0], $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision] + N[(N[Power[Pi, 5.0], $MachinePrecision] * 0.041666666666666664), $MachinePrecision]), $MachinePrecision] - N[(0.008333333333333333 * N[Power[Pi, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(l * N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
F_m = \left|F\right|
\\
\begin{array}{l}
t_0 := \frac{{F_m}^{2}}{{\pi}^{2}}\\
\mathbf{if}\;F_m \leq 1.1 \cdot 10^{-161}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\tan \left(\ell \cdot {\left(\sqrt{\pi}\right)}^{2}\right)}{F_m}}{F_m}\\
\mathbf{elif}\;F_m \leq 3 \cdot 10^{-52}:\\
\;\;\;\;\pi \cdot \ell + \frac{-1}{\left(\frac{{F_m}^{2}}{\pi \cdot \ell} - t_0 \cdot \left({\pi}^{3} \cdot \left(\ell \cdot 0.3333333333333333\right)\right)\right) + {\ell}^{3} \cdot \left(\frac{{F_m}^{2}}{{\pi}^{3}} \cdot {\left({\pi}^{3} \cdot 0.3333333333333333\right)}^{2} + t_0 \cdot \left(\mathsf{fma}\left(-0.5, {\pi}^{3} \cdot \left({\pi}^{2} \cdot 0.3333333333333333\right), {\pi}^{5} \cdot 0.041666666666666664\right) - 0.008333333333333333 \cdot {\pi}^{5}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\tan \left(\ell \cdot \sqrt[3]{{\pi}^{3}}\right)}{F_m}}{F_m}\\
\end{array}
\end{array}
if F < 1.10000000000000001e-161Initial program 65.5%
associate-*l/65.6%
*-un-lft-identity65.6%
associate-/r*74.8%
Applied egg-rr74.8%
add-sqr-sqrt74.9%
pow274.9%
Applied egg-rr74.9%
if 1.10000000000000001e-161 < F < 3e-52Initial program 71.9%
associate-/r/71.8%
associate-/l*71.9%
clear-num71.9%
add-sqr-sqrt71.8%
sqrt-prod71.9%
sqr-neg71.9%
sqrt-unprod0.0%
add-sqr-sqrt29.7%
associate-/r*29.7%
clear-num29.7%
add-sqr-sqrt0.0%
sqrt-unprod71.8%
sqr-neg71.8%
sqrt-prod71.6%
add-sqr-sqrt71.8%
pow271.8%
Applied egg-rr71.8%
Taylor expanded in l around 0 86.8%
Simplified86.8%
if 3e-52 < F Initial program 99.6%
associate-*l/99.6%
*-un-lft-identity99.6%
associate-/r*99.6%
Applied egg-rr99.6%
add-cbrt-cube99.6%
pow399.6%
Applied egg-rr99.6%
Final simplification82.3%
F_m = (fabs.f64 F)
(FPCore (F_m l)
:precision binary64
(if (<= F_m 4.5e-171)
(- (* PI l) (/ (/ (tan (* l (pow (sqrt PI) 2.0))) F_m) F_m))
(if (<= F_m 2e-51)
(+
(* PI l)
(/
-1.0
(-
(/ (pow F_m 2.0) (* PI l))
(*
(/ (pow F_m 2.0) (pow PI 2.0))
(* (pow PI 3.0) (* l 0.3333333333333333))))))
(- (* PI l) (/ (/ (tan (* l (cbrt (pow PI 3.0)))) F_m) F_m)))))F_m = fabs(F);
double code(double F_m, double l) {
double tmp;
if (F_m <= 4.5e-171) {
tmp = (((double) M_PI) * l) - ((tan((l * pow(sqrt(((double) M_PI)), 2.0))) / F_m) / F_m);
} else if (F_m <= 2e-51) {
tmp = (((double) M_PI) * l) + (-1.0 / ((pow(F_m, 2.0) / (((double) M_PI) * l)) - ((pow(F_m, 2.0) / pow(((double) M_PI), 2.0)) * (pow(((double) M_PI), 3.0) * (l * 0.3333333333333333)))));
} else {
tmp = (((double) M_PI) * l) - ((tan((l * cbrt(pow(((double) M_PI), 3.0)))) / F_m) / F_m);
}
return tmp;
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
double tmp;
if (F_m <= 4.5e-171) {
tmp = (Math.PI * l) - ((Math.tan((l * Math.pow(Math.sqrt(Math.PI), 2.0))) / F_m) / F_m);
} else if (F_m <= 2e-51) {
tmp = (Math.PI * l) + (-1.0 / ((Math.pow(F_m, 2.0) / (Math.PI * l)) - ((Math.pow(F_m, 2.0) / Math.pow(Math.PI, 2.0)) * (Math.pow(Math.PI, 3.0) * (l * 0.3333333333333333)))));
} else {
tmp = (Math.PI * l) - ((Math.tan((l * Math.cbrt(Math.pow(Math.PI, 3.0)))) / F_m) / F_m);
}
return tmp;
}
F_m = abs(F) function code(F_m, l) tmp = 0.0 if (F_m <= 4.5e-171) tmp = Float64(Float64(pi * l) - Float64(Float64(tan(Float64(l * (sqrt(pi) ^ 2.0))) / F_m) / F_m)); elseif (F_m <= 2e-51) tmp = Float64(Float64(pi * l) + Float64(-1.0 / Float64(Float64((F_m ^ 2.0) / Float64(pi * l)) - Float64(Float64((F_m ^ 2.0) / (pi ^ 2.0)) * Float64((pi ^ 3.0) * Float64(l * 0.3333333333333333)))))); else tmp = Float64(Float64(pi * l) - Float64(Float64(tan(Float64(l * cbrt((pi ^ 3.0)))) / F_m) / F_m)); end return tmp end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := If[LessEqual[F$95$m, 4.5e-171], N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(l * N[Power[N[Sqrt[Pi], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision], If[LessEqual[F$95$m, 2e-51], N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[(Pi * l), $MachinePrecision]), $MachinePrecision] - N[(N[(N[Power[F$95$m, 2.0], $MachinePrecision] / N[Power[Pi, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[Pi, 3.0], $MachinePrecision] * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(l * N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
F_m = \left|F\right|
\\
\begin{array}{l}
\mathbf{if}\;F_m \leq 4.5 \cdot 10^{-171}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\tan \left(\ell \cdot {\left(\sqrt{\pi}\right)}^{2}\right)}{F_m}}{F_m}\\
\mathbf{elif}\;F_m \leq 2 \cdot 10^{-51}:\\
\;\;\;\;\pi \cdot \ell + \frac{-1}{\frac{{F_m}^{2}}{\pi \cdot \ell} - \frac{{F_m}^{2}}{{\pi}^{2}} \cdot \left({\pi}^{3} \cdot \left(\ell \cdot 0.3333333333333333\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\tan \left(\ell \cdot \sqrt[3]{{\pi}^{3}}\right)}{F_m}}{F_m}\\
\end{array}
\end{array}
if F < 4.5000000000000004e-171Initial program 65.5%
associate-*l/65.6%
*-un-lft-identity65.6%
associate-/r*74.8%
Applied egg-rr74.8%
add-sqr-sqrt74.9%
pow274.9%
Applied egg-rr74.9%
if 4.5000000000000004e-171 < F < 2e-51Initial program 71.9%
associate-/r/71.8%
associate-/l*71.9%
clear-num71.9%
add-sqr-sqrt71.8%
sqrt-prod71.9%
sqr-neg71.9%
sqrt-unprod0.0%
add-sqr-sqrt29.7%
associate-/r*29.7%
clear-num29.7%
add-sqr-sqrt0.0%
sqrt-unprod71.8%
sqr-neg71.8%
sqrt-prod71.6%
add-sqr-sqrt71.8%
pow271.8%
Applied egg-rr71.8%
Taylor expanded in l around 0 77.9%
+-commutative77.9%
mul-1-neg77.9%
unsub-neg77.9%
associate-/l*77.9%
associate-/r/77.9%
*-commutative77.9%
distribute-rgt-out--77.9%
metadata-eval77.9%
associate-*l*77.9%
Simplified77.9%
if 2e-51 < F Initial program 99.6%
associate-*l/99.6%
*-un-lft-identity99.6%
associate-/r*99.6%
Applied egg-rr99.6%
add-cbrt-cube99.6%
pow399.6%
Applied egg-rr99.6%
Final simplification81.6%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (if (<= (* PI l) 500000000.0) (- (* PI l) (/ (/ PI (/ F_m l)) F_m)) (+ (* PI l) (/ (/ (tan (* PI l)) F_m) F_m))))
F_m = fabs(F);
double code(double F_m, double l) {
double tmp;
if ((((double) M_PI) * l) <= 500000000.0) {
tmp = (((double) M_PI) * l) - ((((double) M_PI) / (F_m / l)) / F_m);
} else {
tmp = (((double) M_PI) * l) + ((tan((((double) M_PI) * l)) / F_m) / F_m);
}
return tmp;
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
double tmp;
if ((Math.PI * l) <= 500000000.0) {
tmp = (Math.PI * l) - ((Math.PI / (F_m / l)) / F_m);
} else {
tmp = (Math.PI * l) + ((Math.tan((Math.PI * l)) / F_m) / F_m);
}
return tmp;
}
F_m = math.fabs(F) def code(F_m, l): tmp = 0 if (math.pi * l) <= 500000000.0: tmp = (math.pi * l) - ((math.pi / (F_m / l)) / F_m) else: tmp = (math.pi * l) + ((math.tan((math.pi * l)) / F_m) / F_m) return tmp
F_m = abs(F) function code(F_m, l) tmp = 0.0 if (Float64(pi * l) <= 500000000.0) tmp = Float64(Float64(pi * l) - Float64(Float64(pi / Float64(F_m / l)) / F_m)); else tmp = Float64(Float64(pi * l) + Float64(Float64(tan(Float64(pi * l)) / F_m) / F_m)); end return tmp end
F_m = abs(F); function tmp_2 = code(F_m, l) tmp = 0.0; if ((pi * l) <= 500000000.0) tmp = (pi * l) - ((pi / (F_m / l)) / F_m); else tmp = (pi * l) + ((tan((pi * l)) / F_m) / F_m); end tmp_2 = tmp; end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := If[LessEqual[N[(Pi * l), $MachinePrecision], 500000000.0], N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi / N[(F$95$m / l), $MachinePrecision]), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] + N[(N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
F_m = \left|F\right|
\\
\begin{array}{l}
\mathbf{if}\;\pi \cdot \ell \leq 500000000:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\pi}{\frac{F_m}{\ell}}}{F_m}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell + \frac{\frac{\tan \left(\pi \cdot \ell\right)}{F_m}}{F_m}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 5e8Initial program 78.1%
associate-*l/78.2%
*-un-lft-identity78.2%
associate-/r*86.5%
Applied egg-rr86.5%
Taylor expanded in l around 0 79.2%
*-commutative79.2%
associate-/l*79.3%
Simplified79.3%
if 5e8 < (*.f64 (PI.f64) l) Initial program 66.5%
fma-neg66.5%
distribute-lft-neg-in66.5%
sqr-neg66.5%
distribute-neg-frac66.5%
metadata-eval66.5%
distribute-lft-neg-out66.5%
neg-mul-166.5%
associate-/r*66.5%
metadata-eval66.5%
associate-*l/66.5%
*-lft-identity66.5%
associate-/l/66.5%
Simplified66.5%
fma-udef66.5%
+-commutative66.5%
associate-/l/66.5%
associate-/r*66.5%
add-sqr-sqrt33.4%
sqrt-unprod66.4%
sqr-neg66.4%
sqrt-prod32.9%
add-sqr-sqrt66.5%
associate-/r*66.5%
div-inv66.5%
pow266.5%
pow-flip66.5%
metadata-eval66.5%
Applied egg-rr66.5%
metadata-eval66.5%
pow-flip66.5%
pow266.5%
div-inv66.5%
associate-/r*66.5%
Applied egg-rr66.5%
Final simplification75.8%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (if (<= (* PI l) 2e-117) (- (* PI l) (/ (/ PI (/ F_m l)) F_m)) (- (* PI l) (/ (tan (* PI l)) (* F_m F_m)))))
F_m = fabs(F);
double code(double F_m, double l) {
double tmp;
if ((((double) M_PI) * l) <= 2e-117) {
tmp = (((double) M_PI) * l) - ((((double) M_PI) / (F_m / l)) / F_m);
} else {
tmp = (((double) M_PI) * l) - (tan((((double) M_PI) * l)) / (F_m * F_m));
}
return tmp;
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
double tmp;
if ((Math.PI * l) <= 2e-117) {
tmp = (Math.PI * l) - ((Math.PI / (F_m / l)) / F_m);
} else {
tmp = (Math.PI * l) - (Math.tan((Math.PI * l)) / (F_m * F_m));
}
return tmp;
}
F_m = math.fabs(F) def code(F_m, l): tmp = 0 if (math.pi * l) <= 2e-117: tmp = (math.pi * l) - ((math.pi / (F_m / l)) / F_m) else: tmp = (math.pi * l) - (math.tan((math.pi * l)) / (F_m * F_m)) return tmp
F_m = abs(F) function code(F_m, l) tmp = 0.0 if (Float64(pi * l) <= 2e-117) tmp = Float64(Float64(pi * l) - Float64(Float64(pi / Float64(F_m / l)) / F_m)); else tmp = Float64(Float64(pi * l) - Float64(tan(Float64(pi * l)) / Float64(F_m * F_m))); end return tmp end
F_m = abs(F); function tmp_2 = code(F_m, l) tmp = 0.0; if ((pi * l) <= 2e-117) tmp = (pi * l) - ((pi / (F_m / l)) / F_m); else tmp = (pi * l) - (tan((pi * l)) / (F_m * F_m)); end tmp_2 = tmp; end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := If[LessEqual[N[(Pi * l), $MachinePrecision], 2e-117], N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi / N[(F$95$m / l), $MachinePrecision]), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / N[(F$95$m * F$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
F_m = \left|F\right|
\\
\begin{array}{l}
\mathbf{if}\;\pi \cdot \ell \leq 2 \cdot 10^{-117}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\pi}{\frac{F_m}{\ell}}}{F_m}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\tan \left(\pi \cdot \ell\right)}{F_m \cdot F_m}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 2.00000000000000006e-117Initial program 75.0%
associate-*l/75.0%
*-un-lft-identity75.0%
associate-/r*84.6%
Applied egg-rr84.6%
Taylor expanded in l around 0 76.2%
*-commutative76.2%
associate-/l*76.3%
Simplified76.3%
if 2.00000000000000006e-117 < (*.f64 (PI.f64) l) Initial program 74.9%
sqr-neg74.9%
associate-*l/74.9%
sqr-neg74.9%
*-lft-identity74.9%
Simplified74.9%
Final simplification75.8%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (if (<= (* PI l) 500000000.0) (- (* PI l) (/ (/ PI (/ F_m l)) F_m)) (+ (* PI l) (* (* PI l) (pow F_m -2.0)))))
F_m = fabs(F);
double code(double F_m, double l) {
double tmp;
if ((((double) M_PI) * l) <= 500000000.0) {
tmp = (((double) M_PI) * l) - ((((double) M_PI) / (F_m / l)) / F_m);
} else {
tmp = (((double) M_PI) * l) + ((((double) M_PI) * l) * pow(F_m, -2.0));
}
return tmp;
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
double tmp;
if ((Math.PI * l) <= 500000000.0) {
tmp = (Math.PI * l) - ((Math.PI / (F_m / l)) / F_m);
} else {
tmp = (Math.PI * l) + ((Math.PI * l) * Math.pow(F_m, -2.0));
}
return tmp;
}
F_m = math.fabs(F) def code(F_m, l): tmp = 0 if (math.pi * l) <= 500000000.0: tmp = (math.pi * l) - ((math.pi / (F_m / l)) / F_m) else: tmp = (math.pi * l) + ((math.pi * l) * math.pow(F_m, -2.0)) return tmp
F_m = abs(F) function code(F_m, l) tmp = 0.0 if (Float64(pi * l) <= 500000000.0) tmp = Float64(Float64(pi * l) - Float64(Float64(pi / Float64(F_m / l)) / F_m)); else tmp = Float64(Float64(pi * l) + Float64(Float64(pi * l) * (F_m ^ -2.0))); end return tmp end
F_m = abs(F); function tmp_2 = code(F_m, l) tmp = 0.0; if ((pi * l) <= 500000000.0) tmp = (pi * l) - ((pi / (F_m / l)) / F_m); else tmp = (pi * l) + ((pi * l) * (F_m ^ -2.0)); end tmp_2 = tmp; end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := If[LessEqual[N[(Pi * l), $MachinePrecision], 500000000.0], N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi / N[(F$95$m / l), $MachinePrecision]), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] + N[(N[(Pi * l), $MachinePrecision] * N[Power[F$95$m, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
F_m = \left|F\right|
\\
\begin{array}{l}
\mathbf{if}\;\pi \cdot \ell \leq 500000000:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\pi}{\frac{F_m}{\ell}}}{F_m}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell + \left(\pi \cdot \ell\right) \cdot {F_m}^{-2}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 5e8Initial program 78.1%
associate-*l/78.2%
*-un-lft-identity78.2%
associate-/r*86.5%
Applied egg-rr86.5%
Taylor expanded in l around 0 79.2%
*-commutative79.2%
associate-/l*79.3%
Simplified79.3%
if 5e8 < (*.f64 (PI.f64) l) Initial program 66.5%
fma-neg66.5%
distribute-lft-neg-in66.5%
sqr-neg66.5%
distribute-neg-frac66.5%
metadata-eval66.5%
distribute-lft-neg-out66.5%
neg-mul-166.5%
associate-/r*66.5%
metadata-eval66.5%
associate-*l/66.5%
*-lft-identity66.5%
associate-/l/66.5%
Simplified66.5%
fma-udef66.5%
+-commutative66.5%
associate-/l/66.5%
associate-/r*66.5%
add-sqr-sqrt33.4%
sqrt-unprod66.4%
sqr-neg66.4%
sqrt-prod32.9%
add-sqr-sqrt66.5%
associate-/r*66.5%
div-inv66.5%
pow266.5%
pow-flip66.5%
metadata-eval66.5%
Applied egg-rr66.5%
Taylor expanded in l around 0 57.0%
Final simplification73.2%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (+ (* PI l) (/ -1.0 (* F_m (/ F_m (tan (* PI l)))))))
F_m = fabs(F);
double code(double F_m, double l) {
return (((double) M_PI) * l) + (-1.0 / (F_m * (F_m / tan((((double) M_PI) * l)))));
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
return (Math.PI * l) + (-1.0 / (F_m * (F_m / Math.tan((Math.PI * l)))));
}
F_m = math.fabs(F) def code(F_m, l): return (math.pi * l) + (-1.0 / (F_m * (F_m / math.tan((math.pi * l)))))
F_m = abs(F) function code(F_m, l) return Float64(Float64(pi * l) + Float64(-1.0 / Float64(F_m * Float64(F_m / tan(Float64(pi * l)))))) end
F_m = abs(F); function tmp = code(F_m, l) tmp = (pi * l) + (-1.0 / (F_m * (F_m / tan((pi * l))))); end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := N[(N[(Pi * l), $MachinePrecision] + N[(-1.0 / N[(F$95$m * N[(F$95$m / N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
F_m = \left|F\right|
\\
\pi \cdot \ell + \frac{-1}{F_m \cdot \frac{F_m}{\tan \left(\pi \cdot \ell\right)}}
\end{array}
Initial program 75.0%
associate-/r/75.0%
associate-/l*81.1%
clear-num81.1%
add-sqr-sqrt39.5%
sqrt-prod65.1%
sqr-neg65.1%
sqrt-unprod29.2%
add-sqr-sqrt56.7%
associate-/r*56.7%
clear-num56.7%
add-sqr-sqrt29.2%
sqrt-unprod65.1%
sqr-neg65.1%
sqrt-prod35.9%
add-sqr-sqrt75.0%
pow275.0%
Applied egg-rr75.0%
div-inv75.0%
unpow275.0%
associate-*l*81.1%
div-inv81.1%
*-commutative81.1%
Applied egg-rr81.1%
Final simplification81.1%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (- (* PI l) (/ (/ (tan (* PI l)) F_m) F_m)))
F_m = fabs(F);
double code(double F_m, double l) {
return (((double) M_PI) * l) - ((tan((((double) M_PI) * l)) / F_m) / F_m);
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
return (Math.PI * l) - ((Math.tan((Math.PI * l)) / F_m) / F_m);
}
F_m = math.fabs(F) def code(F_m, l): return (math.pi * l) - ((math.tan((math.pi * l)) / F_m) / F_m)
F_m = abs(F) function code(F_m, l) return Float64(Float64(pi * l) - Float64(Float64(tan(Float64(pi * l)) / F_m) / F_m)) end
F_m = abs(F); function tmp = code(F_m, l) tmp = (pi * l) - ((tan((pi * l)) / F_m) / F_m); end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / F$95$m), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
F_m = \left|F\right|
\\
\pi \cdot \ell - \frac{\frac{\tan \left(\pi \cdot \ell\right)}{F_m}}{F_m}
\end{array}
Initial program 75.0%
associate-*l/75.0%
*-un-lft-identity75.0%
associate-/r*81.1%
Applied egg-rr81.1%
Final simplification81.1%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (- (* PI l) (* (/ PI F_m) (/ l F_m))))
F_m = fabs(F);
double code(double F_m, double l) {
return (((double) M_PI) * l) - ((((double) M_PI) / F_m) * (l / F_m));
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
return (Math.PI * l) - ((Math.PI / F_m) * (l / F_m));
}
F_m = math.fabs(F) def code(F_m, l): return (math.pi * l) - ((math.pi / F_m) * (l / F_m))
F_m = abs(F) function code(F_m, l) return Float64(Float64(pi * l) - Float64(Float64(pi / F_m) * Float64(l / F_m))) end
F_m = abs(F); function tmp = code(F_m, l) tmp = (pi * l) - ((pi / F_m) * (l / F_m)); end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi / F$95$m), $MachinePrecision] * N[(l / F$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
F_m = \left|F\right|
\\
\pi \cdot \ell - \frac{\pi}{F_m} \cdot \frac{\ell}{F_m}
\end{array}
Initial program 75.0%
sqr-neg75.0%
associate-*l/75.0%
sqr-neg75.0%
*-lft-identity75.0%
Simplified75.0%
Taylor expanded in l around 0 66.3%
*-commutative66.3%
times-frac72.4%
Applied egg-rr72.4%
Final simplification72.4%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (- (* PI l) (/ PI (* F_m (/ F_m l)))))
F_m = fabs(F);
double code(double F_m, double l) {
return (((double) M_PI) * l) - (((double) M_PI) / (F_m * (F_m / l)));
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
return (Math.PI * l) - (Math.PI / (F_m * (F_m / l)));
}
F_m = math.fabs(F) def code(F_m, l): return (math.pi * l) - (math.pi / (F_m * (F_m / l)))
F_m = abs(F) function code(F_m, l) return Float64(Float64(pi * l) - Float64(pi / Float64(F_m * Float64(F_m / l)))) end
F_m = abs(F); function tmp = code(F_m, l) tmp = (pi * l) - (pi / (F_m * (F_m / l))); end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(Pi / N[(F$95$m * N[(F$95$m / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
F_m = \left|F\right|
\\
\pi \cdot \ell - \frac{\pi}{F_m \cdot \frac{F_m}{\ell}}
\end{array}
Initial program 75.0%
sqr-neg75.0%
associate-*l/75.0%
sqr-neg75.0%
*-lft-identity75.0%
Simplified75.0%
Taylor expanded in l around 0 66.3%
*-commutative66.3%
times-frac72.4%
Applied egg-rr72.4%
*-commutative72.4%
clear-num72.4%
frac-times72.4%
*-un-lft-identity72.4%
Applied egg-rr72.4%
Final simplification72.4%
F_m = (fabs.f64 F) (FPCore (F_m l) :precision binary64 (- (* PI l) (/ (/ PI (/ F_m l)) F_m)))
F_m = fabs(F);
double code(double F_m, double l) {
return (((double) M_PI) * l) - ((((double) M_PI) / (F_m / l)) / F_m);
}
F_m = Math.abs(F);
public static double code(double F_m, double l) {
return (Math.PI * l) - ((Math.PI / (F_m / l)) / F_m);
}
F_m = math.fabs(F) def code(F_m, l): return (math.pi * l) - ((math.pi / (F_m / l)) / F_m)
F_m = abs(F) function code(F_m, l) return Float64(Float64(pi * l) - Float64(Float64(pi / Float64(F_m / l)) / F_m)) end
F_m = abs(F); function tmp = code(F_m, l) tmp = (pi * l) - ((pi / (F_m / l)) / F_m); end
F_m = N[Abs[F], $MachinePrecision] code[F$95$m_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi / N[(F$95$m / l), $MachinePrecision]), $MachinePrecision] / F$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
F_m = \left|F\right|
\\
\pi \cdot \ell - \frac{\frac{\pi}{\frac{F_m}{\ell}}}{F_m}
\end{array}
Initial program 75.0%
associate-*l/75.0%
*-un-lft-identity75.0%
associate-/r*81.1%
Applied egg-rr81.1%
Taylor expanded in l around 0 72.4%
*-commutative72.4%
associate-/l*72.4%
Simplified72.4%
Final simplification72.4%
herbie shell --seed 2023318
(FPCore (F l)
:name "VandenBroeck and Keller, Equation (6)"
:precision binary64
(- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))