
(FPCore (x) :precision binary64 (- (/ PI 2.0) (* 2.0 (asin (sqrt (/ (- 1.0 x) 2.0))))))
double code(double x) {
return (((double) M_PI) / 2.0) - (2.0 * asin(sqrt(((1.0 - x) / 2.0))));
}
public static double code(double x) {
return (Math.PI / 2.0) - (2.0 * Math.asin(Math.sqrt(((1.0 - x) / 2.0))));
}
def code(x): return (math.pi / 2.0) - (2.0 * math.asin(math.sqrt(((1.0 - x) / 2.0))))
function code(x) return Float64(Float64(pi / 2.0) - Float64(2.0 * asin(sqrt(Float64(Float64(1.0 - x) / 2.0))))) end
function tmp = code(x) tmp = (pi / 2.0) - (2.0 * asin(sqrt(((1.0 - x) / 2.0)))); end
code[x_] := N[(N[(Pi / 2.0), $MachinePrecision] - N[(2.0 * N[ArcSin[N[Sqrt[N[(N[(1.0 - x), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\pi}{2} - 2 \cdot \sin^{-1} \left(\sqrt{\frac{1 - x}{2}}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (- (/ PI 2.0) (* 2.0 (asin (sqrt (/ (- 1.0 x) 2.0))))))
double code(double x) {
return (((double) M_PI) / 2.0) - (2.0 * asin(sqrt(((1.0 - x) / 2.0))));
}
public static double code(double x) {
return (Math.PI / 2.0) - (2.0 * Math.asin(Math.sqrt(((1.0 - x) / 2.0))));
}
def code(x): return (math.pi / 2.0) - (2.0 * math.asin(math.sqrt(((1.0 - x) / 2.0))))
function code(x) return Float64(Float64(pi / 2.0) - Float64(2.0 * asin(sqrt(Float64(Float64(1.0 - x) / 2.0))))) end
function tmp = code(x) tmp = (pi / 2.0) - (2.0 * asin(sqrt(((1.0 - x) / 2.0)))); end
code[x_] := N[(N[(Pi / 2.0), $MachinePrecision] - N[(2.0 * N[ArcSin[N[Sqrt[N[(N[(1.0 - x), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\pi}{2} - 2 \cdot \sin^{-1} \left(\sqrt{\frac{1 - x}{2}}\right)
\end{array}
(FPCore (x)
:precision binary64
(let* ((t_0 (asin (sqrt (- 0.5 (* 0.5 x))))) (t_1 (* 2.0 t_0)))
(/
(/
(-
(pow (* PI 0.5) 6.0)
(pow (* 2.0 (- (* PI 0.5) (acos (sqrt (+ 0.5 (* -0.5 x)))))) 6.0))
(+ (pow (* PI 0.5) 4.0) (+ (pow t_1 4.0) (pow (* (* PI 0.5) t_1) 2.0))))
(fma 2.0 t_0 (* PI 0.5)))))
double code(double x) {
double t_0 = asin(sqrt((0.5 - (0.5 * x))));
double t_1 = 2.0 * t_0;
return ((pow((((double) M_PI) * 0.5), 6.0) - pow((2.0 * ((((double) M_PI) * 0.5) - acos(sqrt((0.5 + (-0.5 * x)))))), 6.0)) / (pow((((double) M_PI) * 0.5), 4.0) + (pow(t_1, 4.0) + pow(((((double) M_PI) * 0.5) * t_1), 2.0)))) / fma(2.0, t_0, (((double) M_PI) * 0.5));
}
function code(x) t_0 = asin(sqrt(Float64(0.5 - Float64(0.5 * x)))) t_1 = Float64(2.0 * t_0) return Float64(Float64(Float64((Float64(pi * 0.5) ^ 6.0) - (Float64(2.0 * Float64(Float64(pi * 0.5) - acos(sqrt(Float64(0.5 + Float64(-0.5 * x)))))) ^ 6.0)) / Float64((Float64(pi * 0.5) ^ 4.0) + Float64((t_1 ^ 4.0) + (Float64(Float64(pi * 0.5) * t_1) ^ 2.0)))) / fma(2.0, t_0, Float64(pi * 0.5))) end
code[x_] := Block[{t$95$0 = N[ArcSin[N[Sqrt[N[(0.5 - N[(0.5 * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(2.0 * t$95$0), $MachinePrecision]}, N[(N[(N[(N[Power[N[(Pi * 0.5), $MachinePrecision], 6.0], $MachinePrecision] - N[Power[N[(2.0 * N[(N[(Pi * 0.5), $MachinePrecision] - N[ArcCos[N[Sqrt[N[(0.5 + N[(-0.5 * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 6.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[(Pi * 0.5), $MachinePrecision], 4.0], $MachinePrecision] + N[(N[Power[t$95$1, 4.0], $MachinePrecision] + N[Power[N[(N[(Pi * 0.5), $MachinePrecision] * t$95$1), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 * t$95$0 + N[(Pi * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sin^{-1} \left(\sqrt{0.5 - 0.5 \cdot x}\right)\\
t_1 := 2 \cdot t\_0\\
\frac{\frac{{\left(\pi \cdot 0.5\right)}^{6} - {\left(2 \cdot \left(\pi \cdot 0.5 - \cos^{-1} \left(\sqrt{0.5 + -0.5 \cdot x}\right)\right)\right)}^{6}}{{\left(\pi \cdot 0.5\right)}^{4} + \left({t\_1}^{4} + {\left(\left(\pi \cdot 0.5\right) \cdot t\_1\right)}^{2}\right)}}{\mathsf{fma}\left(2, t\_0, \pi \cdot 0.5\right)}
\end{array}
\end{array}
Initial program 8.0%
flip--7.9%
pow27.9%
div-inv7.9%
metadata-eval7.9%
pow27.9%
div-sub7.9%
metadata-eval7.9%
div-inv7.9%
metadata-eval7.9%
+-commutative7.9%
Applied egg-rr7.9%
flip3--7.9%
Applied egg-rr8.0%
asin-acos9.5%
div-inv9.5%
metadata-eval9.5%
cancel-sign-sub-inv9.5%
metadata-eval9.5%
Applied egg-rr9.5%
Final simplification9.5%
(FPCore (x) :precision binary64 (+ (/ PI 2.0) (* 2.0 (- (acos (sqrt (+ 0.5 (* -0.5 x)))) (/ PI 2.0)))))
double code(double x) {
return (((double) M_PI) / 2.0) + (2.0 * (acos(sqrt((0.5 + (-0.5 * x)))) - (((double) M_PI) / 2.0)));
}
public static double code(double x) {
return (Math.PI / 2.0) + (2.0 * (Math.acos(Math.sqrt((0.5 + (-0.5 * x)))) - (Math.PI / 2.0)));
}
def code(x): return (math.pi / 2.0) + (2.0 * (math.acos(math.sqrt((0.5 + (-0.5 * x)))) - (math.pi / 2.0)))
function code(x) return Float64(Float64(pi / 2.0) + Float64(2.0 * Float64(acos(sqrt(Float64(0.5 + Float64(-0.5 * x)))) - Float64(pi / 2.0)))) end
function tmp = code(x) tmp = (pi / 2.0) + (2.0 * (acos(sqrt((0.5 + (-0.5 * x)))) - (pi / 2.0))); end
code[x_] := N[(N[(Pi / 2.0), $MachinePrecision] + N[(2.0 * N[(N[ArcCos[N[Sqrt[N[(0.5 + N[(-0.5 * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] - N[(Pi / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\pi}{2} + 2 \cdot \left(\cos^{-1} \left(\sqrt{0.5 + -0.5 \cdot x}\right) - \frac{\pi}{2}\right)
\end{array}
Initial program 8.0%
asin-acos9.4%
add-cube-cbrt7.0%
associate-/l*7.0%
fma-neg7.0%
pow27.0%
div-sub7.0%
metadata-eval7.0%
div-inv7.0%
metadata-eval7.0%
Applied egg-rr7.0%
fma-neg7.0%
associate-*r/7.0%
unpow27.0%
rem-3cbrt-lft9.4%
sub-neg9.4%
distribute-rgt-neg-in9.4%
metadata-eval9.4%
Simplified9.4%
Final simplification9.4%
(FPCore (x) :precision binary64 (if (<= x -2e-310) (- (/ PI 2.0) (* 2.0 (asin (sqrt 0.5)))) (- (/ PI 2.0) (* 2.0 (asin (/ 1.0 (sqrt 2.0)))))))
double code(double x) {
double tmp;
if (x <= -2e-310) {
tmp = (((double) M_PI) / 2.0) - (2.0 * asin(sqrt(0.5)));
} else {
tmp = (((double) M_PI) / 2.0) - (2.0 * asin((1.0 / sqrt(2.0))));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -2e-310) {
tmp = (Math.PI / 2.0) - (2.0 * Math.asin(Math.sqrt(0.5)));
} else {
tmp = (Math.PI / 2.0) - (2.0 * Math.asin((1.0 / Math.sqrt(2.0))));
}
return tmp;
}
def code(x): tmp = 0 if x <= -2e-310: tmp = (math.pi / 2.0) - (2.0 * math.asin(math.sqrt(0.5))) else: tmp = (math.pi / 2.0) - (2.0 * math.asin((1.0 / math.sqrt(2.0)))) return tmp
function code(x) tmp = 0.0 if (x <= -2e-310) tmp = Float64(Float64(pi / 2.0) - Float64(2.0 * asin(sqrt(0.5)))); else tmp = Float64(Float64(pi / 2.0) - Float64(2.0 * asin(Float64(1.0 / sqrt(2.0))))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -2e-310) tmp = (pi / 2.0) - (2.0 * asin(sqrt(0.5))); else tmp = (pi / 2.0) - (2.0 * asin((1.0 / sqrt(2.0)))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -2e-310], N[(N[(Pi / 2.0), $MachinePrecision] - N[(2.0 * N[ArcSin[N[Sqrt[0.5], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(Pi / 2.0), $MachinePrecision] - N[(2.0 * N[ArcSin[N[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2 \cdot 10^{-310}:\\
\;\;\;\;\frac{\pi}{2} - 2 \cdot \sin^{-1} \left(\sqrt{0.5}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\pi}{2} - 2 \cdot \sin^{-1} \left(\frac{1}{\sqrt{2}}\right)\\
\end{array}
\end{array}
if x < -1.999999999999994e-310Initial program 8.1%
Taylor expanded in x around 0 5.9%
if -1.999999999999994e-310 < x Initial program 7.8%
clear-num7.8%
sqrt-div10.3%
metadata-eval10.3%
Applied egg-rr10.3%
Taylor expanded in x around 0 6.0%
(FPCore (x) :precision binary64 (- (/ PI 2.0) (* 2.0 (asin (sqrt (/ (- 1.0 x) 2.0))))))
double code(double x) {
return (((double) M_PI) / 2.0) - (2.0 * asin(sqrt(((1.0 - x) / 2.0))));
}
public static double code(double x) {
return (Math.PI / 2.0) - (2.0 * Math.asin(Math.sqrt(((1.0 - x) / 2.0))));
}
def code(x): return (math.pi / 2.0) - (2.0 * math.asin(math.sqrt(((1.0 - x) / 2.0))))
function code(x) return Float64(Float64(pi / 2.0) - Float64(2.0 * asin(sqrt(Float64(Float64(1.0 - x) / 2.0))))) end
function tmp = code(x) tmp = (pi / 2.0) - (2.0 * asin(sqrt(((1.0 - x) / 2.0)))); end
code[x_] := N[(N[(Pi / 2.0), $MachinePrecision] - N[(2.0 * N[ArcSin[N[Sqrt[N[(N[(1.0 - x), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\pi}{2} - 2 \cdot \sin^{-1} \left(\sqrt{\frac{1 - x}{2}}\right)
\end{array}
Initial program 8.0%
(FPCore (x) :precision binary64 (- (/ PI 2.0) (* 2.0 (asin (sqrt 0.5)))))
double code(double x) {
return (((double) M_PI) / 2.0) - (2.0 * asin(sqrt(0.5)));
}
public static double code(double x) {
return (Math.PI / 2.0) - (2.0 * Math.asin(Math.sqrt(0.5)));
}
def code(x): return (math.pi / 2.0) - (2.0 * math.asin(math.sqrt(0.5)))
function code(x) return Float64(Float64(pi / 2.0) - Float64(2.0 * asin(sqrt(0.5)))) end
function tmp = code(x) tmp = (pi / 2.0) - (2.0 * asin(sqrt(0.5))); end
code[x_] := N[(N[(Pi / 2.0), $MachinePrecision] - N[(2.0 * N[ArcSin[N[Sqrt[0.5], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\pi}{2} - 2 \cdot \sin^{-1} \left(\sqrt{0.5}\right)
\end{array}
Initial program 8.0%
Taylor expanded in x around 0 4.3%
(FPCore (x) :precision binary64 (asin x))
double code(double x) {
return asin(x);
}
real(8) function code(x)
real(8), intent (in) :: x
code = asin(x)
end function
public static double code(double x) {
return Math.asin(x);
}
def code(x): return math.asin(x)
function code(x) return asin(x) end
function tmp = code(x) tmp = asin(x); end
code[x_] := N[ArcSin[x], $MachinePrecision]
\begin{array}{l}
\\
\sin^{-1} x
\end{array}
herbie shell --seed 2024101
(FPCore (x)
:name "Ian Simplification"
:precision binary64
:alt
(asin x)
(- (/ PI 2.0) (* 2.0 (asin (sqrt (/ (- 1.0 x) 2.0))))))