
(FPCore (x) :precision binary64 (acosh x))
double code(double x) {
return acosh(x);
}
def code(x): return math.acosh(x)
function code(x) return acosh(x) end
function tmp = code(x) tmp = acosh(x); end
code[x_] := N[ArcCosh[x], $MachinePrecision]
\begin{array}{l}
\\
\cosh^{-1} x
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 6 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (log (+ x (sqrt (- (* x x) 1.0)))))
double code(double x) {
return log((x + sqrt(((x * x) - 1.0))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + sqrt(((x * x) - 1.0d0))))
end function
public static double code(double x) {
return Math.log((x + Math.sqrt(((x * x) - 1.0))));
}
def code(x): return math.log((x + math.sqrt(((x * x) - 1.0))))
function code(x) return log(Float64(x + sqrt(Float64(Float64(x * x) - 1.0)))) end
function tmp = code(x) tmp = log((x + sqrt(((x * x) - 1.0)))); end
code[x_] := N[Log[N[(x + N[Sqrt[N[(N[(x * x), $MachinePrecision] - 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + \sqrt{x \cdot x - 1}\right)
\end{array}
(FPCore (x)
:precision binary64
(log
(+
x
(*
x
(+
1.0
(/
(/ 1.0 x)
(+ (/ 0.5 x) (* x (+ -2.0 (/ 0.125 (* (* x x) (* x x))))))))))))
double code(double x) {
return log((x + (x * (1.0 + ((1.0 / x) / ((0.5 / x) + (x * (-2.0 + (0.125 / ((x * x) * (x * x)))))))))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + (x * (1.0d0 + ((1.0d0 / x) / ((0.5d0 / x) + (x * ((-2.0d0) + (0.125d0 / ((x * x) * (x * x)))))))))))
end function
public static double code(double x) {
return Math.log((x + (x * (1.0 + ((1.0 / x) / ((0.5 / x) + (x * (-2.0 + (0.125 / ((x * x) * (x * x)))))))))));
}
def code(x): return math.log((x + (x * (1.0 + ((1.0 / x) / ((0.5 / x) + (x * (-2.0 + (0.125 / ((x * x) * (x * x)))))))))))
function code(x) return log(Float64(x + Float64(x * Float64(1.0 + Float64(Float64(1.0 / x) / Float64(Float64(0.5 / x) + Float64(x * Float64(-2.0 + Float64(0.125 / Float64(Float64(x * x) * Float64(x * x))))))))))) end
function tmp = code(x) tmp = log((x + (x * (1.0 + ((1.0 / x) / ((0.5 / x) + (x * (-2.0 + (0.125 / ((x * x) * (x * x))))))))))); end
code[x_] := N[Log[N[(x + N[(x * N[(1.0 + N[(N[(1.0 / x), $MachinePrecision] / N[(N[(0.5 / x), $MachinePrecision] + N[(x * N[(-2.0 + N[(0.125 / N[(N[(x * x), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + x \cdot \left(1 + \frac{\frac{1}{x}}{\frac{0.5}{x} + x \cdot \left(-2 + \frac{0.125}{\left(x \cdot x\right) \cdot \left(x \cdot x\right)}\right)}\right)\right)
\end{array}
Initial program 53.1%
Taylor expanded in x around inf 99.8%
associate--l+99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
associate-*r/99.8%
metadata-eval99.8%
pow-sqr99.8%
unpow299.8%
unpow299.8%
times-frac99.8%
metadata-eval99.8%
distribute-neg-frac99.8%
unpow299.8%
Simplified99.8%
associate-*l/99.8%
clear-num99.8%
+-commutative99.8%
distribute-lft-in99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Taylor expanded in x around inf 99.8%
unpow299.8%
*-commutative99.8%
associate--l+99.8%
+-commutative99.8%
sub-neg99.8%
unpow299.8%
associate-*r/99.8%
metadata-eval99.8%
metadata-eval99.8%
metadata-eval99.8%
pow-plus99.8%
cube-unmult99.8%
*-commutative99.8%
Simplified99.8%
*-un-lft-identity99.8%
*-commutative99.8%
associate-/r*99.8%
associate-+l+99.8%
associate-*r*99.8%
Applied egg-rr99.8%
*-lft-identity99.8%
associate-/r*99.8%
associate-/r*99.8%
distribute-lft-in99.8%
associate-*r/99.8%
times-frac99.8%
*-inverses99.8%
*-commutative99.8%
*-rgt-identity99.8%
Simplified99.8%
(FPCore (x)
:precision binary64
(log
(+
x
(*
x
(+
1.0
(/ 1.0 (/ (* x x) (- -0.5 (/ (+ 0.125 (/ 0.0625 (* x x))) (* x x))))))))))
double code(double x) {
return log((x + (x * (1.0 + (1.0 / ((x * x) / (-0.5 - ((0.125 + (0.0625 / (x * x))) / (x * x)))))))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + (x * (1.0d0 + (1.0d0 / ((x * x) / ((-0.5d0) - ((0.125d0 + (0.0625d0 / (x * x))) / (x * x)))))))))
end function
public static double code(double x) {
return Math.log((x + (x * (1.0 + (1.0 / ((x * x) / (-0.5 - ((0.125 + (0.0625 / (x * x))) / (x * x)))))))));
}
def code(x): return math.log((x + (x * (1.0 + (1.0 / ((x * x) / (-0.5 - ((0.125 + (0.0625 / (x * x))) / (x * x)))))))))
function code(x) return log(Float64(x + Float64(x * Float64(1.0 + Float64(1.0 / Float64(Float64(x * x) / Float64(-0.5 - Float64(Float64(0.125 + Float64(0.0625 / Float64(x * x))) / Float64(x * x))))))))) end
function tmp = code(x) tmp = log((x + (x * (1.0 + (1.0 / ((x * x) / (-0.5 - ((0.125 + (0.0625 / (x * x))) / (x * x))))))))); end
code[x_] := N[Log[N[(x + N[(x * N[(1.0 + N[(1.0 / N[(N[(x * x), $MachinePrecision] / N[(-0.5 - N[(N[(0.125 + N[(0.0625 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + x \cdot \left(1 + \frac{1}{\frac{x \cdot x}{-0.5 - \frac{0.125 + \frac{0.0625}{x \cdot x}}{x \cdot x}}}\right)\right)
\end{array}
Initial program 53.1%
Taylor expanded in x around inf 99.8%
associate--l+99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
associate-*r/99.8%
metadata-eval99.8%
pow-sqr99.8%
unpow299.8%
unpow299.8%
times-frac99.8%
metadata-eval99.8%
distribute-neg-frac99.8%
unpow299.8%
Simplified99.8%
associate-*l/99.8%
clear-num99.8%
+-commutative99.8%
distribute-lft-in99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (x)
:precision binary64
(log
(+
x
(*
x
(+ 1.0 (/ (+ -0.5 (/ (+ -0.125 (/ -0.0625 (* x x))) (* x x))) (* x x)))))))
double code(double x) {
return log((x + (x * (1.0 + ((-0.5 + ((-0.125 + (-0.0625 / (x * x))) / (x * x))) / (x * x))))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + (x * (1.0d0 + (((-0.5d0) + (((-0.125d0) + ((-0.0625d0) / (x * x))) / (x * x))) / (x * x))))))
end function
public static double code(double x) {
return Math.log((x + (x * (1.0 + ((-0.5 + ((-0.125 + (-0.0625 / (x * x))) / (x * x))) / (x * x))))));
}
def code(x): return math.log((x + (x * (1.0 + ((-0.5 + ((-0.125 + (-0.0625 / (x * x))) / (x * x))) / (x * x))))))
function code(x) return log(Float64(x + Float64(x * Float64(1.0 + Float64(Float64(-0.5 + Float64(Float64(-0.125 + Float64(-0.0625 / Float64(x * x))) / Float64(x * x))) / Float64(x * x)))))) end
function tmp = code(x) tmp = log((x + (x * (1.0 + ((-0.5 + ((-0.125 + (-0.0625 / (x * x))) / (x * x))) / (x * x)))))); end
code[x_] := N[Log[N[(x + N[(x * N[(1.0 + N[(N[(-0.5 + N[(N[(-0.125 + N[(-0.0625 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + x \cdot \left(1 + \frac{-0.5 + \frac{-0.125 + \frac{-0.0625}{x \cdot x}}{x \cdot x}}{x \cdot x}\right)\right)
\end{array}
Initial program 53.1%
Taylor expanded in x around inf 99.8%
associate--l+99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
associate-*r/99.8%
metadata-eval99.8%
pow-sqr99.8%
unpow299.8%
unpow299.8%
times-frac99.8%
metadata-eval99.8%
distribute-neg-frac99.8%
unpow299.8%
Simplified99.8%
Taylor expanded in x around inf 99.8%
Simplified99.8%
(FPCore (x) :precision binary64 (log (+ x (+ x (/ 1.0 (+ (/ 0.5 x) (* x -2.0)))))))
double code(double x) {
return log((x + (x + (1.0 / ((0.5 / x) + (x * -2.0))))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + (x + (1.0d0 / ((0.5d0 / x) + (x * (-2.0d0)))))))
end function
public static double code(double x) {
return Math.log((x + (x + (1.0 / ((0.5 / x) + (x * -2.0))))));
}
def code(x): return math.log((x + (x + (1.0 / ((0.5 / x) + (x * -2.0))))))
function code(x) return log(Float64(x + Float64(x + Float64(1.0 / Float64(Float64(0.5 / x) + Float64(x * -2.0)))))) end
function tmp = code(x) tmp = log((x + (x + (1.0 / ((0.5 / x) + (x * -2.0)))))); end
code[x_] := N[Log[N[(x + N[(x + N[(1.0 / N[(N[(0.5 / x), $MachinePrecision] + N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + \left(x + \frac{1}{\frac{0.5}{x} + x \cdot -2}\right)\right)
\end{array}
Initial program 53.1%
Taylor expanded in x around inf 99.8%
associate--l+99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
associate-*r/99.8%
metadata-eval99.8%
pow-sqr99.8%
unpow299.8%
unpow299.8%
times-frac99.8%
metadata-eval99.8%
distribute-neg-frac99.8%
unpow299.8%
Simplified99.8%
associate-*l/99.8%
clear-num99.8%
+-commutative99.8%
distribute-lft-in99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Taylor expanded in x around inf 99.7%
unpow299.7%
associate-*l*99.7%
sub-neg99.7%
unpow299.7%
associate-*r/99.7%
metadata-eval99.7%
metadata-eval99.7%
Simplified99.7%
distribute-lft-in99.7%
*-rgt-identity99.7%
un-div-inv99.7%
Applied egg-rr99.7%
associate-/r*99.7%
*-inverses99.7%
distribute-lft-in99.7%
+-commutative99.7%
associate-*r/99.7%
times-frac99.7%
*-inverses99.7%
*-commutative99.7%
*-rgt-identity99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (x) :precision binary64 (log (+ x (+ x (/ -0.5 x)))))
double code(double x) {
return log((x + (x + (-0.5 / x))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + (x + ((-0.5d0) / x))))
end function
public static double code(double x) {
return Math.log((x + (x + (-0.5 / x))));
}
def code(x): return math.log((x + (x + (-0.5 / x))))
function code(x) return log(Float64(x + Float64(x + Float64(-0.5 / x)))) end
function tmp = code(x) tmp = log((x + (x + (-0.5 / x)))); end
code[x_] := N[Log[N[(x + N[(x + N[(-0.5 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + \left(x + \frac{-0.5}{x}\right)\right)
\end{array}
Initial program 53.1%
Taylor expanded in x around inf 99.6%
sub-neg99.6%
distribute-rgt-in99.6%
*-lft-identity99.6%
distribute-lft-neg-in99.6%
associate-*l*99.6%
unpow299.6%
associate-*l/99.6%
*-lft-identity99.6%
associate-/r*99.6%
*-inverses99.6%
associate-*r/99.6%
metadata-eval99.6%
metadata-eval99.6%
Simplified99.6%
(FPCore (x) :precision binary64 (log (+ x x)))
double code(double x) {
return log((x + x));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + x))
end function
public static double code(double x) {
return Math.log((x + x));
}
def code(x): return math.log((x + x))
function code(x) return log(Float64(x + x)) end
function tmp = code(x) tmp = log((x + x)); end
code[x_] := N[Log[N[(x + x), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + x\right)
\end{array}
Initial program 53.1%
Taylor expanded in x around inf 99.3%
(FPCore (x) :precision binary64 (log (+ x (* (sqrt (- x 1.0)) (sqrt (+ x 1.0))))))
double code(double x) {
return log((x + (sqrt((x - 1.0)) * sqrt((x + 1.0)))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log((x + (sqrt((x - 1.0d0)) * sqrt((x + 1.0d0)))))
end function
public static double code(double x) {
return Math.log((x + (Math.sqrt((x - 1.0)) * Math.sqrt((x + 1.0)))));
}
def code(x): return math.log((x + (math.sqrt((x - 1.0)) * math.sqrt((x + 1.0)))))
function code(x) return log(Float64(x + Float64(sqrt(Float64(x - 1.0)) * sqrt(Float64(x + 1.0))))) end
function tmp = code(x) tmp = log((x + (sqrt((x - 1.0)) * sqrt((x + 1.0))))); end
code[x_] := N[Log[N[(x + N[(N[Sqrt[N[(x - 1.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(x + \sqrt{x - 1} \cdot \sqrt{x + 1}\right)
\end{array}
herbie shell --seed 2024107
(FPCore (x)
:name "Rust f64::acosh"
:precision binary64
:pre (>= x 1.0)
:alt
(log (+ x (* (sqrt (- x 1.0)) (sqrt (+ x 1.0)))))
(log (+ x (sqrt (- (* x x) 1.0)))))