
(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 7 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}
(FPCore (F l) :precision binary64 (fma PI l (/ (/ (tan (* l (cbrt (pow PI 3.0)))) F) (- F))))
double code(double F, double l) {
return fma(((double) M_PI), l, ((tan((l * cbrt(pow(((double) M_PI), 3.0)))) / F) / -F));
}
function code(F, l) return fma(pi, l, Float64(Float64(tan(Float64(l * cbrt((pi ^ 3.0)))) / F) / Float64(-F))) end
code[F_, l_] := N[(Pi * l + N[(N[(N[Tan[N[(l * N[Power[N[Power[Pi, 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / F), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\pi, \ell, \frac{\frac{\tan \left(\ell \cdot \sqrt[3]{{\pi}^{3}}\right)}{F}}{-F}\right)
\end{array}
Initial program 76.7%
fma-neg76.7%
distribute-lft-neg-in76.7%
sqr-neg76.7%
distribute-neg-frac76.7%
metadata-eval76.7%
distribute-lft-neg-out76.7%
neg-mul-176.7%
associate-/r*76.7%
metadata-eval76.7%
associate-*l/77.1%
*-lft-identity77.1%
associate-/r*83.6%
Simplified83.6%
add-cbrt-cube83.7%
pow383.7%
Applied egg-rr83.7%
Final simplification83.7%
(FPCore (F l) :precision binary64 (fma PI l (/ (* (/ 1.0 F) (tan (* PI l))) (- F))))
double code(double F, double l) {
return fma(((double) M_PI), l, (((1.0 / F) * tan((((double) M_PI) * l))) / -F));
}
function code(F, l) return fma(pi, l, Float64(Float64(Float64(1.0 / F) * tan(Float64(pi * l))) / Float64(-F))) end
code[F_, l_] := N[(Pi * l + N[(N[(N[(1.0 / F), $MachinePrecision] * N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\pi, \ell, \frac{\frac{1}{F} \cdot \tan \left(\pi \cdot \ell\right)}{-F}\right)
\end{array}
Initial program 76.7%
fma-neg76.7%
distribute-lft-neg-in76.7%
sqr-neg76.7%
distribute-neg-frac76.7%
metadata-eval76.7%
distribute-lft-neg-out76.7%
neg-mul-176.7%
associate-/r*76.7%
metadata-eval76.7%
associate-*l/77.1%
*-lft-identity77.1%
associate-/r*83.6%
Simplified83.6%
clear-num83.6%
associate-/r/83.6%
Applied egg-rr83.6%
Final simplification83.6%
(FPCore (F l) :precision binary64 (fma PI l (/ (/ (tan (* PI l)) F) (- F))))
double code(double F, double l) {
return fma(((double) M_PI), l, ((tan((((double) M_PI) * l)) / F) / -F));
}
function code(F, l) return fma(pi, l, Float64(Float64(tan(Float64(pi * l)) / F) / Float64(-F))) end
code[F_, l_] := N[(Pi * l + N[(N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / F), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\pi, \ell, \frac{\frac{\tan \left(\pi \cdot \ell\right)}{F}}{-F}\right)
\end{array}
Initial program 76.7%
fma-neg76.7%
distribute-lft-neg-in76.7%
sqr-neg76.7%
distribute-neg-frac76.7%
metadata-eval76.7%
distribute-lft-neg-out76.7%
neg-mul-176.7%
associate-/r*76.7%
metadata-eval76.7%
associate-*l/77.1%
*-lft-identity77.1%
associate-/r*83.6%
Simplified83.6%
Final simplification83.6%
(FPCore (F l) :precision binary64 (if (<= (* PI l) 4e-68) (fma PI l (/ (* PI (/ l F)) (- F))) (- (* PI l) (* (tan (* PI l)) (/ 1.0 (* F F))))))
double code(double F, double l) {
double tmp;
if ((((double) M_PI) * l) <= 4e-68) {
tmp = fma(((double) M_PI), l, ((((double) M_PI) * (l / F)) / -F));
} else {
tmp = (((double) M_PI) * l) - (tan((((double) M_PI) * l)) * (1.0 / (F * F)));
}
return tmp;
}
function code(F, l) tmp = 0.0 if (Float64(pi * l) <= 4e-68) tmp = fma(pi, l, Float64(Float64(pi * Float64(l / F)) / Float64(-F))); else tmp = Float64(Float64(pi * l) - Float64(tan(Float64(pi * l)) * Float64(1.0 / Float64(F * F)))); end return tmp end
code[F_, l_] := If[LessEqual[N[(Pi * l), $MachinePrecision], 4e-68], N[(Pi * l + N[(N[(Pi * N[(l / F), $MachinePrecision]), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] * N[(1.0 / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\pi \cdot \ell \leq 4 \cdot 10^{-68}:\\
\;\;\;\;\mathsf{fma}\left(\pi, \ell, \frac{\pi \cdot \frac{\ell}{F}}{-F}\right)\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \tan \left(\pi \cdot \ell\right) \cdot \frac{1}{F \cdot F}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 4.00000000000000027e-68Initial program 76.8%
fma-neg76.8%
distribute-lft-neg-in76.8%
sqr-neg76.8%
distribute-neg-frac76.8%
metadata-eval76.8%
distribute-lft-neg-out76.8%
neg-mul-176.8%
associate-/r*76.8%
metadata-eval76.8%
associate-*l/77.3%
*-lft-identity77.3%
associate-/r*87.1%
Simplified87.1%
Taylor expanded in l around 0 83.4%
associate-/l*83.4%
associate-/r/83.4%
Simplified83.4%
if 4.00000000000000027e-68 < (*.f64 (PI.f64) l) Initial program 76.5%
Final simplification81.1%
(FPCore (F l) :precision binary64 (if (<= (* PI l) 4e-68) (fma PI l (/ (* PI (/ l F)) (- F))) (- (* PI l) (/ (tan (* PI l)) (* F F)))))
double code(double F, double l) {
double tmp;
if ((((double) M_PI) * l) <= 4e-68) {
tmp = fma(((double) M_PI), l, ((((double) M_PI) * (l / F)) / -F));
} else {
tmp = (((double) M_PI) * l) - (tan((((double) M_PI) * l)) / (F * F));
}
return tmp;
}
function code(F, l) tmp = 0.0 if (Float64(pi * l) <= 4e-68) tmp = fma(pi, l, Float64(Float64(pi * Float64(l / F)) / Float64(-F))); else tmp = Float64(Float64(pi * l) - Float64(tan(Float64(pi * l)) / Float64(F * F))); end return tmp end
code[F_, l_] := If[LessEqual[N[(Pi * l), $MachinePrecision], 4e-68], N[(Pi * l + N[(N[(Pi * N[(l / F), $MachinePrecision]), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\pi \cdot \ell \leq 4 \cdot 10^{-68}:\\
\;\;\;\;\mathsf{fma}\left(\pi, \ell, \frac{\pi \cdot \frac{\ell}{F}}{-F}\right)\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\tan \left(\pi \cdot \ell\right)}{F \cdot F}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 4.00000000000000027e-68Initial program 76.8%
fma-neg76.8%
distribute-lft-neg-in76.8%
sqr-neg76.8%
distribute-neg-frac76.8%
metadata-eval76.8%
distribute-lft-neg-out76.8%
neg-mul-176.8%
associate-/r*76.8%
metadata-eval76.8%
associate-*l/77.3%
*-lft-identity77.3%
associate-/r*87.1%
Simplified87.1%
Taylor expanded in l around 0 83.4%
associate-/l*83.4%
associate-/r/83.4%
Simplified83.4%
if 4.00000000000000027e-68 < (*.f64 (PI.f64) l) Initial program 76.5%
sqr-neg76.5%
associate-*l/76.5%
*-lft-identity76.5%
sqr-neg76.5%
Simplified76.5%
Final simplification81.1%
(FPCore (F l) :precision binary64 (fma PI l (/ (* PI (/ l F)) (- F))))
double code(double F, double l) {
return fma(((double) M_PI), l, ((((double) M_PI) * (l / F)) / -F));
}
function code(F, l) return fma(pi, l, Float64(Float64(pi * Float64(l / F)) / Float64(-F))) end
code[F_, l_] := N[(Pi * l + N[(N[(Pi * N[(l / F), $MachinePrecision]), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\pi, \ell, \frac{\pi \cdot \frac{\ell}{F}}{-F}\right)
\end{array}
Initial program 76.7%
fma-neg76.7%
distribute-lft-neg-in76.7%
sqr-neg76.7%
distribute-neg-frac76.7%
metadata-eval76.7%
distribute-lft-neg-out76.7%
neg-mul-176.7%
associate-/r*76.7%
metadata-eval76.7%
associate-*l/77.1%
*-lft-identity77.1%
associate-/r*83.6%
Simplified83.6%
Taylor expanded in l around 0 74.9%
associate-/l*74.9%
associate-/r/74.9%
Simplified74.9%
Final simplification74.9%
(FPCore (F l) :precision binary64 (- (* PI l) (/ (* PI l) (* F F))))
double code(double F, double l) {
return (((double) M_PI) * l) - ((((double) M_PI) * l) / (F * F));
}
public static double code(double F, double l) {
return (Math.PI * l) - ((Math.PI * l) / (F * F));
}
def code(F, l): return (math.pi * l) - ((math.pi * l) / (F * F))
function code(F, l) return Float64(Float64(pi * l) - Float64(Float64(pi * l) / Float64(F * F))) end
function tmp = code(F, l) tmp = (pi * l) - ((pi * l) / (F * F)); end
code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(Pi * l), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\pi \cdot \ell - \frac{\pi \cdot \ell}{F \cdot F}
\end{array}
Initial program 76.7%
sqr-neg76.7%
associate-*l/77.1%
*-lft-identity77.1%
sqr-neg77.1%
Simplified77.1%
Taylor expanded in l around 0 68.3%
Final simplification68.3%
herbie shell --seed 2024039
(FPCore (F l)
:name "VandenBroeck and Keller, Equation (6)"
:precision binary64
(- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))