
(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 5 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}
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 1e+16)
(- (* PI l_m) (/ (/ (tan (* PI l_m)) F) F))
(expm1 (log1p (* PI l_m))))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((((double) M_PI) * l_m) <= 1e+16) {
tmp = (((double) M_PI) * l_m) - ((tan((((double) M_PI) * l_m)) / F) / F);
} else {
tmp = expm1(log1p((((double) M_PI) * l_m)));
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if ((Math.PI * l_m) <= 1e+16) {
tmp = (Math.PI * l_m) - ((Math.tan((Math.PI * l_m)) / F) / F);
} else {
tmp = Math.expm1(Math.log1p((Math.PI * l_m)));
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if (math.pi * l_m) <= 1e+16: tmp = (math.pi * l_m) - ((math.tan((math.pi * l_m)) / F) / F) else: tmp = math.expm1(math.log1p((math.pi * l_m))) return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (Float64(pi * l_m) <= 1e+16) tmp = Float64(Float64(pi * l_m) - Float64(Float64(tan(Float64(pi * l_m)) / F) / F)); else tmp = expm1(log1p(Float64(pi * l_m))); end return Float64(l_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 1e+16], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(N[Tan[N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision] / F), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision], N[(Exp[N[Log[1 + N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;\pi \cdot l_m \leq 10^{+16}:\\
\;\;\;\;\pi \cdot l_m - \frac{\frac{\tan \left(\pi \cdot l_m\right)}{F}}{F}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{expm1}\left(\mathsf{log1p}\left(\pi \cdot l_m\right)\right)\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 1e16Initial program 79.4%
associate-*l/80.8%
*-un-lft-identity80.8%
associate-/r*87.7%
Applied egg-rr87.7%
if 1e16 < (*.f64 (PI.f64) l) Initial program 59.3%
fma-neg59.3%
distribute-lft-neg-in59.3%
sqr-neg59.3%
distribute-neg-frac59.3%
metadata-eval59.3%
distribute-lft-neg-out59.3%
neg-mul-159.3%
associate-/r*59.3%
metadata-eval59.3%
associate-*l/59.3%
*-lft-identity59.3%
associate-/l/59.3%
Simplified59.3%
expm1-log1p-u54.3%
associate-/l/54.3%
associate-/r*54.3%
add-sqr-sqrt23.6%
sqrt-unprod54.2%
sqr-neg54.2%
sqrt-prod30.6%
add-sqr-sqrt54.1%
associate-/r*54.1%
div-inv54.1%
pow254.1%
pow-flip54.1%
metadata-eval54.1%
Applied egg-rr54.1%
Taylor expanded in F around inf 91.3%
log1p-def91.3%
Simplified91.3%
Final simplification88.5%
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 10000.0)
(fma PI l_m (/ (/ (- l_m) (/ F PI)) F))
(expm1 (log1p (* PI l_m))))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((((double) M_PI) * l_m) <= 10000.0) {
tmp = fma(((double) M_PI), l_m, ((-l_m / (F / ((double) M_PI))) / F));
} else {
tmp = expm1(log1p((((double) M_PI) * l_m)));
}
return l_s * tmp;
}
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (Float64(pi * l_m) <= 10000.0) tmp = fma(pi, l_m, Float64(Float64(Float64(-l_m) / Float64(F / pi)) / F)); else tmp = expm1(log1p(Float64(pi * l_m))); end return Float64(l_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 10000.0], N[(Pi * l$95$m + N[(N[((-l$95$m) / N[(F / Pi), $MachinePrecision]), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision], N[(Exp[N[Log[1 + N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;\pi \cdot l_m \leq 10000:\\
\;\;\;\;\mathsf{fma}\left(\pi, l_m, \frac{\frac{-l_m}{\frac{F}{\pi}}}{F}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{expm1}\left(\mathsf{log1p}\left(\pi \cdot l_m\right)\right)\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 1e4Initial program 79.3%
fma-neg79.3%
distribute-lft-neg-in79.3%
sqr-neg79.3%
distribute-neg-frac79.3%
metadata-eval79.3%
distribute-lft-neg-out79.3%
neg-mul-179.3%
associate-/r*79.3%
metadata-eval79.3%
associate-*l/80.7%
*-lft-identity80.7%
associate-/l/87.7%
Simplified87.7%
Taylor expanded in l around 0 80.2%
mul-1-neg80.2%
associate-/l*80.2%
Simplified80.2%
if 1e4 < (*.f64 (PI.f64) l) Initial program 60.3%
fma-neg60.3%
distribute-lft-neg-in60.3%
sqr-neg60.3%
distribute-neg-frac60.3%
metadata-eval60.3%
distribute-lft-neg-out60.3%
neg-mul-160.3%
associate-/r*60.3%
metadata-eval60.3%
associate-*l/60.3%
*-lft-identity60.3%
associate-/l/60.3%
Simplified60.3%
expm1-log1p-u55.5%
associate-/l/55.5%
associate-/r*55.5%
add-sqr-sqrt25.9%
sqrt-unprod55.4%
sqr-neg55.4%
sqrt-prod29.5%
add-sqr-sqrt53.9%
associate-/r*53.9%
div-inv53.9%
pow253.9%
pow-flip53.9%
metadata-eval53.9%
Applied egg-rr53.9%
Taylor expanded in F around inf 89.9%
log1p-def89.9%
Simplified89.9%
Final simplification82.3%
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= l_m 3400.0)
(- (* PI l_m) (/ (/ l_m F) (/ F PI)))
(expm1 (log1p (* PI l_m))))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if (l_m <= 3400.0) {
tmp = (((double) M_PI) * l_m) - ((l_m / F) / (F / ((double) M_PI)));
} else {
tmp = expm1(log1p((((double) M_PI) * l_m)));
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if (l_m <= 3400.0) {
tmp = (Math.PI * l_m) - ((l_m / F) / (F / Math.PI));
} else {
tmp = Math.expm1(Math.log1p((Math.PI * l_m)));
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if l_m <= 3400.0: tmp = (math.pi * l_m) - ((l_m / F) / (F / math.pi)) else: tmp = math.expm1(math.log1p((math.pi * l_m))) return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (l_m <= 3400.0) tmp = Float64(Float64(pi * l_m) - Float64(Float64(l_m / F) / Float64(F / pi))); else tmp = expm1(log1p(Float64(pi * l_m))); end return Float64(l_s * tmp) end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[l$95$m, 3400.0], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(l$95$m / F), $MachinePrecision] / N[(F / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(Exp[N[Log[1 + N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;l_m \leq 3400:\\
\;\;\;\;\pi \cdot l_m - \frac{\frac{l_m}{F}}{\frac{F}{\pi}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{expm1}\left(\mathsf{log1p}\left(\pi \cdot l_m\right)\right)\\
\end{array}
\end{array}
if l < 3400Initial program 79.3%
sqr-neg79.3%
associate-*l/80.7%
sqr-neg80.7%
*-lft-identity80.7%
Simplified80.7%
Taylor expanded in l around 0 73.2%
*-commutative73.2%
times-frac80.2%
Applied egg-rr80.2%
*-commutative80.2%
clear-num80.1%
un-div-inv80.2%
Applied egg-rr80.2%
if 3400 < l Initial program 60.3%
fma-neg60.3%
distribute-lft-neg-in60.3%
sqr-neg60.3%
distribute-neg-frac60.3%
metadata-eval60.3%
distribute-lft-neg-out60.3%
neg-mul-160.3%
associate-/r*60.3%
metadata-eval60.3%
associate-*l/60.3%
*-lft-identity60.3%
associate-/l/60.3%
Simplified60.3%
expm1-log1p-u55.5%
associate-/l/55.5%
associate-/r*55.5%
add-sqr-sqrt25.9%
sqrt-unprod55.4%
sqr-neg55.4%
sqrt-prod29.5%
add-sqr-sqrt53.9%
associate-/r*53.9%
div-inv53.9%
pow253.9%
pow-flip53.9%
metadata-eval53.9%
Applied egg-rr53.9%
Taylor expanded in F around inf 89.9%
log1p-def89.9%
Simplified89.9%
Final simplification82.3%
l_m = (fabs.f64 l) l_s = (copysign.f64 1 l) (FPCore (l_s F l_m) :precision binary64 (* l_s (- (* PI l_m) (* (/ l_m F) (/ PI F)))))
l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
return l_s * ((((double) M_PI) * l_m) - ((l_m / F) * (((double) M_PI) / F)));
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
return l_s * ((Math.PI * l_m) - ((l_m / F) * (Math.PI / F)));
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): return l_s * ((math.pi * l_m) - ((l_m / F) * (math.pi / F)))
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) return Float64(l_s * Float64(Float64(pi * l_m) - Float64(Float64(l_m / F) * Float64(pi / F)))) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp = code(l_s, F, l_m) tmp = l_s * ((pi * l_m) - ((l_m / F) * (pi / F))); end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(l$95$m / F), $MachinePrecision] * N[(Pi / F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \left(\pi \cdot l_m - \frac{l_m}{F} \cdot \frac{\pi}{F}\right)
\end{array}
Initial program 75.1%
sqr-neg75.1%
associate-*l/76.2%
sqr-neg76.2%
*-lft-identity76.2%
Simplified76.2%
Taylor expanded in l around 0 69.0%
*-commutative69.0%
times-frac74.4%
Applied egg-rr74.4%
Final simplification74.4%
l_m = (fabs.f64 l) l_s = (copysign.f64 1 l) (FPCore (l_s F l_m) :precision binary64 (* l_s (- (* PI l_m) (/ (/ l_m F) (/ F PI)))))
l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
return l_s * ((((double) M_PI) * l_m) - ((l_m / F) / (F / ((double) M_PI))));
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
return l_s * ((Math.PI * l_m) - ((l_m / F) / (F / Math.PI)));
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): return l_s * ((math.pi * l_m) - ((l_m / F) / (F / math.pi)))
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) return Float64(l_s * Float64(Float64(pi * l_m) - Float64(Float64(l_m / F) / Float64(F / pi)))) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp = code(l_s, F, l_m) tmp = l_s * ((pi * l_m) - ((l_m / F) / (F / pi))); end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(l$95$m / F), $MachinePrecision] / N[(F / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \left(\pi \cdot l_m - \frac{\frac{l_m}{F}}{\frac{F}{\pi}}\right)
\end{array}
Initial program 75.1%
sqr-neg75.1%
associate-*l/76.2%
sqr-neg76.2%
*-lft-identity76.2%
Simplified76.2%
Taylor expanded in l around 0 69.0%
*-commutative69.0%
times-frac74.4%
Applied egg-rr74.4%
*-commutative74.4%
clear-num74.4%
un-div-inv74.4%
Applied egg-rr74.4%
Final simplification74.4%
herbie shell --seed 2023339
(FPCore (F l)
:name "VandenBroeck and Keller, Equation (6)"
:precision binary64
(- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))