
(FPCore (f) :precision binary64 (let* ((t_0 (* (/ PI 4.0) f)) (t_1 (exp t_0)) (t_2 (exp (- t_0)))) (- (* (/ 1.0 (/ PI 4.0)) (log (/ (+ t_1 t_2) (- t_1 t_2)))))))
double code(double f) {
double t_0 = (((double) M_PI) / 4.0) * f;
double t_1 = exp(t_0);
double t_2 = exp(-t_0);
return -((1.0 / (((double) M_PI) / 4.0)) * log(((t_1 + t_2) / (t_1 - t_2))));
}
public static double code(double f) {
double t_0 = (Math.PI / 4.0) * f;
double t_1 = Math.exp(t_0);
double t_2 = Math.exp(-t_0);
return -((1.0 / (Math.PI / 4.0)) * Math.log(((t_1 + t_2) / (t_1 - t_2))));
}
def code(f): t_0 = (math.pi / 4.0) * f t_1 = math.exp(t_0) t_2 = math.exp(-t_0) return -((1.0 / (math.pi / 4.0)) * math.log(((t_1 + t_2) / (t_1 - t_2))))
function code(f) t_0 = Float64(Float64(pi / 4.0) * f) t_1 = exp(t_0) t_2 = exp(Float64(-t_0)) return Float64(-Float64(Float64(1.0 / Float64(pi / 4.0)) * log(Float64(Float64(t_1 + t_2) / Float64(t_1 - t_2))))) end
function tmp = code(f) t_0 = (pi / 4.0) * f; t_1 = exp(t_0); t_2 = exp(-t_0); tmp = -((1.0 / (pi / 4.0)) * log(((t_1 + t_2) / (t_1 - t_2)))); end
code[f_] := Block[{t$95$0 = N[(N[(Pi / 4.0), $MachinePrecision] * f), $MachinePrecision]}, Block[{t$95$1 = N[Exp[t$95$0], $MachinePrecision]}, Block[{t$95$2 = N[Exp[(-t$95$0)], $MachinePrecision]}, (-N[(N[(1.0 / N[(Pi / 4.0), $MachinePrecision]), $MachinePrecision] * N[Log[N[(N[(t$95$1 + t$95$2), $MachinePrecision] / N[(t$95$1 - t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision])]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\pi}{4} \cdot f\\
t_1 := e^{t\_0}\\
t_2 := e^{-t\_0}\\
-\frac{1}{\frac{\pi}{4}} \cdot \log \left(\frac{t\_1 + t\_2}{t\_1 - t\_2}\right)
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 7 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (f) :precision binary64 (let* ((t_0 (* (/ PI 4.0) f)) (t_1 (exp t_0)) (t_2 (exp (- t_0)))) (- (* (/ 1.0 (/ PI 4.0)) (log (/ (+ t_1 t_2) (- t_1 t_2)))))))
double code(double f) {
double t_0 = (((double) M_PI) / 4.0) * f;
double t_1 = exp(t_0);
double t_2 = exp(-t_0);
return -((1.0 / (((double) M_PI) / 4.0)) * log(((t_1 + t_2) / (t_1 - t_2))));
}
public static double code(double f) {
double t_0 = (Math.PI / 4.0) * f;
double t_1 = Math.exp(t_0);
double t_2 = Math.exp(-t_0);
return -((1.0 / (Math.PI / 4.0)) * Math.log(((t_1 + t_2) / (t_1 - t_2))));
}
def code(f): t_0 = (math.pi / 4.0) * f t_1 = math.exp(t_0) t_2 = math.exp(-t_0) return -((1.0 / (math.pi / 4.0)) * math.log(((t_1 + t_2) / (t_1 - t_2))))
function code(f) t_0 = Float64(Float64(pi / 4.0) * f) t_1 = exp(t_0) t_2 = exp(Float64(-t_0)) return Float64(-Float64(Float64(1.0 / Float64(pi / 4.0)) * log(Float64(Float64(t_1 + t_2) / Float64(t_1 - t_2))))) end
function tmp = code(f) t_0 = (pi / 4.0) * f; t_1 = exp(t_0); t_2 = exp(-t_0); tmp = -((1.0 / (pi / 4.0)) * log(((t_1 + t_2) / (t_1 - t_2)))); end
code[f_] := Block[{t$95$0 = N[(N[(Pi / 4.0), $MachinePrecision] * f), $MachinePrecision]}, Block[{t$95$1 = N[Exp[t$95$0], $MachinePrecision]}, Block[{t$95$2 = N[Exp[(-t$95$0)], $MachinePrecision]}, (-N[(N[(1.0 / N[(Pi / 4.0), $MachinePrecision]), $MachinePrecision] * N[Log[N[(N[(t$95$1 + t$95$2), $MachinePrecision] / N[(t$95$1 - t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision])]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\pi}{4} \cdot f\\
t_1 := e^{t\_0}\\
t_2 := e^{-t\_0}\\
-\frac{1}{\frac{\pi}{4}} \cdot \log \left(\frac{t\_1 + t\_2}{t\_1 - t\_2}\right)
\end{array}
\end{array}
(FPCore (f)
:precision binary64
(let* ((t_0 (cbrt (sqrt PI))))
(*
-4.0
(/
(log1p
(+
(/ 1.0 (expm1 (* f (* (* (pow (* t_0 t_0) 2.0) (cbrt PI)) 0.5))))
(+ -1.0 (/ -1.0 (expm1 (* f (* PI -0.5)))))))
PI))))
double code(double f) {
double t_0 = cbrt(sqrt(((double) M_PI)));
return -4.0 * (log1p(((1.0 / expm1((f * ((pow((t_0 * t_0), 2.0) * cbrt(((double) M_PI))) * 0.5)))) + (-1.0 + (-1.0 / expm1((f * (((double) M_PI) * -0.5))))))) / ((double) M_PI));
}
public static double code(double f) {
double t_0 = Math.cbrt(Math.sqrt(Math.PI));
return -4.0 * (Math.log1p(((1.0 / Math.expm1((f * ((Math.pow((t_0 * t_0), 2.0) * Math.cbrt(Math.PI)) * 0.5)))) + (-1.0 + (-1.0 / Math.expm1((f * (Math.PI * -0.5))))))) / Math.PI);
}
function code(f) t_0 = cbrt(sqrt(pi)) return Float64(-4.0 * Float64(log1p(Float64(Float64(1.0 / expm1(Float64(f * Float64(Float64((Float64(t_0 * t_0) ^ 2.0) * cbrt(pi)) * 0.5)))) + Float64(-1.0 + Float64(-1.0 / expm1(Float64(f * Float64(pi * -0.5))))))) / pi)) end
code[f_] := Block[{t$95$0 = N[Power[N[Sqrt[Pi], $MachinePrecision], 1/3], $MachinePrecision]}, N[(-4.0 * N[(N[Log[1 + N[(N[(1.0 / N[(Exp[N[(f * N[(N[(N[Power[N[(t$95$0 * t$95$0), $MachinePrecision], 2.0], $MachinePrecision] * N[Power[Pi, 1/3], $MachinePrecision]), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] + N[(-1.0 + N[(-1.0 / N[(Exp[N[(f * N[(Pi * -0.5), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt[3]{\sqrt{\pi}}\\
-4 \cdot \frac{\mathsf{log1p}\left(\frac{1}{\mathsf{expm1}\left(f \cdot \left(\left({\left(t\_0 \cdot t\_0\right)}^{2} \cdot \sqrt[3]{\pi}\right) \cdot 0.5\right)\right)} + \left(-1 + \frac{-1}{\mathsf{expm1}\left(f \cdot \left(\pi \cdot -0.5\right)\right)}\right)\right)}{\pi}
\end{array}
\end{array}
Initial program 7.9%
Simplified98.8%
Taylor expanded in f around inf 6.8%
expm1-define7.1%
*-commutative7.1%
associate-*l*7.1%
expm1-define98.9%
associate-*r*98.9%
*-commutative98.9%
*-commutative98.9%
Simplified98.9%
log1p-expm1-u98.9%
expm1-undefine98.9%
add-exp-log98.9%
*-commutative98.9%
associate-*r*98.9%
*-commutative98.9%
Applied egg-rr98.9%
sub-neg98.9%
sub-neg98.9%
distribute-neg-frac98.9%
metadata-eval98.9%
metadata-eval98.9%
associate-+l+99.0%
Simplified99.0%
add-cube-cbrt99.0%
pow299.0%
Applied egg-rr99.0%
pow1/399.0%
add-sqr-sqrt99.0%
unpow-prod-down99.0%
Applied egg-rr99.0%
unpow1/399.0%
unpow1/399.0%
Simplified99.0%
Final simplification99.0%
(FPCore (f)
:precision binary64
(*
-4.0
(/
(log1p
(+
(+ -1.0 (/ -1.0 (expm1 (* f (* PI -0.5)))))
(/ 1.0 (expm1 (* f (* PI 0.5))))))
PI)))
double code(double f) {
return -4.0 * (log1p(((-1.0 + (-1.0 / expm1((f * (((double) M_PI) * -0.5))))) + (1.0 / expm1((f * (((double) M_PI) * 0.5)))))) / ((double) M_PI));
}
public static double code(double f) {
return -4.0 * (Math.log1p(((-1.0 + (-1.0 / Math.expm1((f * (Math.PI * -0.5))))) + (1.0 / Math.expm1((f * (Math.PI * 0.5)))))) / Math.PI);
}
def code(f): return -4.0 * (math.log1p(((-1.0 + (-1.0 / math.expm1((f * (math.pi * -0.5))))) + (1.0 / math.expm1((f * (math.pi * 0.5)))))) / math.pi)
function code(f) return Float64(-4.0 * Float64(log1p(Float64(Float64(-1.0 + Float64(-1.0 / expm1(Float64(f * Float64(pi * -0.5))))) + Float64(1.0 / expm1(Float64(f * Float64(pi * 0.5)))))) / pi)) end
code[f_] := N[(-4.0 * N[(N[Log[1 + N[(N[(-1.0 + N[(-1.0 / N[(Exp[N[(f * N[(Pi * -0.5), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(Exp[N[(f * N[(Pi * 0.5), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-4 \cdot \frac{\mathsf{log1p}\left(\left(-1 + \frac{-1}{\mathsf{expm1}\left(f \cdot \left(\pi \cdot -0.5\right)\right)}\right) + \frac{1}{\mathsf{expm1}\left(f \cdot \left(\pi \cdot 0.5\right)\right)}\right)}{\pi}
\end{array}
Initial program 7.9%
Simplified98.8%
Taylor expanded in f around inf 6.8%
expm1-define7.1%
*-commutative7.1%
associate-*l*7.1%
expm1-define98.9%
associate-*r*98.9%
*-commutative98.9%
*-commutative98.9%
Simplified98.9%
log1p-expm1-u98.9%
expm1-undefine98.9%
add-exp-log98.9%
*-commutative98.9%
associate-*r*98.9%
*-commutative98.9%
Applied egg-rr98.9%
sub-neg98.9%
sub-neg98.9%
distribute-neg-frac98.9%
metadata-eval98.9%
metadata-eval98.9%
associate-+l+99.0%
Simplified99.0%
Final simplification99.0%
(FPCore (f)
:precision binary64
(*
-4.0
(/
(log
(+ (/ 1.0 (expm1 (* f (* PI 0.5)))) (/ -1.0 (expm1 (* PI (* f -0.5))))))
PI)))
double code(double f) {
return -4.0 * (log(((1.0 / expm1((f * (((double) M_PI) * 0.5)))) + (-1.0 / expm1((((double) M_PI) * (f * -0.5)))))) / ((double) M_PI));
}
public static double code(double f) {
return -4.0 * (Math.log(((1.0 / Math.expm1((f * (Math.PI * 0.5)))) + (-1.0 / Math.expm1((Math.PI * (f * -0.5)))))) / Math.PI);
}
def code(f): return -4.0 * (math.log(((1.0 / math.expm1((f * (math.pi * 0.5)))) + (-1.0 / math.expm1((math.pi * (f * -0.5)))))) / math.pi)
function code(f) return Float64(-4.0 * Float64(log(Float64(Float64(1.0 / expm1(Float64(f * Float64(pi * 0.5)))) + Float64(-1.0 / expm1(Float64(pi * Float64(f * -0.5)))))) / pi)) end
code[f_] := N[(-4.0 * N[(N[Log[N[(N[(1.0 / N[(Exp[N[(f * N[(Pi * 0.5), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / N[(Exp[N[(Pi * N[(f * -0.5), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-4 \cdot \frac{\log \left(\frac{1}{\mathsf{expm1}\left(f \cdot \left(\pi \cdot 0.5\right)\right)} + \frac{-1}{\mathsf{expm1}\left(\pi \cdot \left(f \cdot -0.5\right)\right)}\right)}{\pi}
\end{array}
Initial program 7.9%
Simplified98.8%
Taylor expanded in f around inf 6.8%
expm1-define7.1%
*-commutative7.1%
associate-*l*7.1%
expm1-define98.9%
associate-*r*98.9%
*-commutative98.9%
*-commutative98.9%
Simplified98.9%
Final simplification98.9%
(FPCore (f)
:precision binary64
(*
-4.0
(/
(log1p
(+
(/ 1.0 (expm1 (* f (* PI 0.5))))
(/
(+ (* f (- (* f (* PI 0.041666666666666664)) 0.5)) (* 2.0 (/ 1.0 PI)))
f)))
PI)))
double code(double f) {
return -4.0 * (log1p(((1.0 / expm1((f * (((double) M_PI) * 0.5)))) + (((f * ((f * (((double) M_PI) * 0.041666666666666664)) - 0.5)) + (2.0 * (1.0 / ((double) M_PI)))) / f))) / ((double) M_PI));
}
public static double code(double f) {
return -4.0 * (Math.log1p(((1.0 / Math.expm1((f * (Math.PI * 0.5)))) + (((f * ((f * (Math.PI * 0.041666666666666664)) - 0.5)) + (2.0 * (1.0 / Math.PI))) / f))) / Math.PI);
}
def code(f): return -4.0 * (math.log1p(((1.0 / math.expm1((f * (math.pi * 0.5)))) + (((f * ((f * (math.pi * 0.041666666666666664)) - 0.5)) + (2.0 * (1.0 / math.pi))) / f))) / math.pi)
function code(f) return Float64(-4.0 * Float64(log1p(Float64(Float64(1.0 / expm1(Float64(f * Float64(pi * 0.5)))) + Float64(Float64(Float64(f * Float64(Float64(f * Float64(pi * 0.041666666666666664)) - 0.5)) + Float64(2.0 * Float64(1.0 / pi))) / f))) / pi)) end
code[f_] := N[(-4.0 * N[(N[Log[1 + N[(N[(1.0 / N[(Exp[N[(f * N[(Pi * 0.5), $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(f * N[(N[(f * N[(Pi * 0.041666666666666664), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(1.0 / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / f), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-4 \cdot \frac{\mathsf{log1p}\left(\frac{1}{\mathsf{expm1}\left(f \cdot \left(\pi \cdot 0.5\right)\right)} + \frac{f \cdot \left(f \cdot \left(\pi \cdot 0.041666666666666664\right) - 0.5\right) + 2 \cdot \frac{1}{\pi}}{f}\right)}{\pi}
\end{array}
Initial program 7.9%
Simplified98.8%
Taylor expanded in f around inf 6.8%
expm1-define7.1%
*-commutative7.1%
associate-*l*7.1%
expm1-define98.9%
associate-*r*98.9%
*-commutative98.9%
*-commutative98.9%
Simplified98.9%
log1p-expm1-u98.9%
expm1-undefine98.9%
add-exp-log98.9%
*-commutative98.9%
associate-*r*98.9%
*-commutative98.9%
Applied egg-rr98.9%
sub-neg98.9%
sub-neg98.9%
distribute-neg-frac98.9%
metadata-eval98.9%
metadata-eval98.9%
associate-+l+99.0%
Simplified99.0%
Taylor expanded in f around 0 96.7%
*-un-lft-identity96.7%
distribute-rgt-out96.7%
metadata-eval96.7%
Applied egg-rr96.7%
*-lft-identity96.7%
Simplified96.7%
(FPCore (f)
:precision binary64
(*
-4.0
(/
(log1p
(/
(+ (* f (+ -1.0 (* PI (* f 0.08333333333333333)))) (* (/ 1.0 PI) 4.0))
f))
PI)))
double code(double f) {
return -4.0 * (log1p((((f * (-1.0 + (((double) M_PI) * (f * 0.08333333333333333)))) + ((1.0 / ((double) M_PI)) * 4.0)) / f)) / ((double) M_PI));
}
public static double code(double f) {
return -4.0 * (Math.log1p((((f * (-1.0 + (Math.PI * (f * 0.08333333333333333)))) + ((1.0 / Math.PI) * 4.0)) / f)) / Math.PI);
}
def code(f): return -4.0 * (math.log1p((((f * (-1.0 + (math.pi * (f * 0.08333333333333333)))) + ((1.0 / math.pi) * 4.0)) / f)) / math.pi)
function code(f) return Float64(-4.0 * Float64(log1p(Float64(Float64(Float64(f * Float64(-1.0 + Float64(pi * Float64(f * 0.08333333333333333)))) + Float64(Float64(1.0 / pi) * 4.0)) / f)) / pi)) end
code[f_] := N[(-4.0 * N[(N[Log[1 + N[(N[(N[(f * N[(-1.0 + N[(Pi * N[(f * 0.08333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(1.0 / Pi), $MachinePrecision] * 4.0), $MachinePrecision]), $MachinePrecision] / f), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-4 \cdot \frac{\mathsf{log1p}\left(\frac{f \cdot \left(-1 + \pi \cdot \left(f \cdot 0.08333333333333333\right)\right) + \frac{1}{\pi} \cdot 4}{f}\right)}{\pi}
\end{array}
Initial program 7.9%
Simplified98.8%
Taylor expanded in f around inf 6.8%
expm1-define7.1%
*-commutative7.1%
associate-*l*7.1%
expm1-define98.9%
associate-*r*98.9%
*-commutative98.9%
*-commutative98.9%
Simplified98.9%
log1p-expm1-u98.9%
expm1-undefine98.9%
add-exp-log98.9%
*-commutative98.9%
associate-*r*98.9%
*-commutative98.9%
Applied egg-rr98.9%
sub-neg98.9%
sub-neg98.9%
distribute-neg-frac98.9%
metadata-eval98.9%
metadata-eval98.9%
associate-+l+99.0%
Simplified99.0%
Taylor expanded in f around 0 96.7%
pow196.7%
distribute-rgt-out96.7%
metadata-eval96.7%
distribute-rgt-out96.7%
metadata-eval96.7%
Applied egg-rr96.7%
unpow196.7%
distribute-lft-out--96.7%
metadata-eval96.7%
*-commutative96.7%
associate-*l*96.7%
Simplified96.7%
Final simplification96.7%
(FPCore (f) :precision binary64 (* -4.0 (/ (log (/ 4.0 (* f PI))) PI)))
double code(double f) {
return -4.0 * (log((4.0 / (f * ((double) M_PI)))) / ((double) M_PI));
}
public static double code(double f) {
return -4.0 * (Math.log((4.0 / (f * Math.PI))) / Math.PI);
}
def code(f): return -4.0 * (math.log((4.0 / (f * math.pi))) / math.pi)
function code(f) return Float64(-4.0 * Float64(log(Float64(4.0 / Float64(f * pi))) / pi)) end
function tmp = code(f) tmp = -4.0 * (log((4.0 / (f * pi))) / pi); end
code[f_] := N[(-4.0 * N[(N[Log[N[(4.0 / N[(f * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-4 \cdot \frac{\log \left(\frac{4}{f \cdot \pi}\right)}{\pi}
\end{array}
Initial program 7.9%
Simplified98.8%
Taylor expanded in f around inf 6.8%
expm1-define7.1%
*-commutative7.1%
associate-*l*7.1%
expm1-define98.9%
associate-*r*98.9%
*-commutative98.9%
*-commutative98.9%
Simplified98.9%
Taylor expanded in f around 0 96.0%
*-commutative96.0%
Simplified96.0%
Final simplification96.0%
(FPCore (f) :precision binary64 0.0)
double code(double f) {
return 0.0;
}
real(8) function code(f)
real(8), intent (in) :: f
code = 0.0d0
end function
public static double code(double f) {
return 0.0;
}
def code(f): return 0.0
function code(f) return 0.0 end
function tmp = code(f) tmp = 0.0; end
code[f_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 7.9%
Simplified98.8%
Applied egg-rr94.3%
rem-cbrt-cube94.7%
flip-+0.0%
log-div0.0%
Applied egg-rr0.0%
+-inverses0.0%
+-inverses0.0%
+-inverses4.6%
Simplified4.6%
mul0-lft4.6%
Applied egg-rr4.6%
herbie shell --seed 2024191
(FPCore (f)
:name "VandenBroeck and Keller, Equation (20)"
:precision binary64
(- (* (/ 1.0 (/ PI 4.0)) (log (/ (+ (exp (* (/ PI 4.0) f)) (exp (- (* (/ PI 4.0) f)))) (- (exp (* (/ PI 4.0) f)) (exp (- (* (/ PI 4.0) f)))))))))