
(FPCore (x) :precision binary64 (log (+ (/ 1.0 x) (/ (sqrt (- 1.0 (* x x))) x))))
double code(double x) {
return log(((1.0 / x) + (sqrt((1.0 - (x * x))) / x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log(((1.0d0 / x) + (sqrt((1.0d0 - (x * x))) / x)))
end function
public static double code(double x) {
return Math.log(((1.0 / x) + (Math.sqrt((1.0 - (x * x))) / x)));
}
def code(x): return math.log(((1.0 / x) + (math.sqrt((1.0 - (x * x))) / x)))
function code(x) return log(Float64(Float64(1.0 / x) + Float64(sqrt(Float64(1.0 - Float64(x * x))) / x))) end
function tmp = code(x) tmp = log(((1.0 / x) + (sqrt((1.0 - (x * x))) / x))); end
code[x_] := N[Log[N[(N[(1.0 / x), $MachinePrecision] + N[(N[Sqrt[N[(1.0 - N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(\frac{1}{x} + \frac{\sqrt{1 - x \cdot x}}{x}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (log (+ (/ 1.0 x) (/ (sqrt (- 1.0 (* x x))) x))))
double code(double x) {
return log(((1.0 / x) + (sqrt((1.0 - (x * x))) / x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log(((1.0d0 / x) + (sqrt((1.0d0 - (x * x))) / x)))
end function
public static double code(double x) {
return Math.log(((1.0 / x) + (Math.sqrt((1.0 - (x * x))) / x)));
}
def code(x): return math.log(((1.0 / x) + (math.sqrt((1.0 - (x * x))) / x)))
function code(x) return log(Float64(Float64(1.0 / x) + Float64(sqrt(Float64(1.0 - Float64(x * x))) / x))) end
function tmp = code(x) tmp = log(((1.0 / x) + (sqrt((1.0 - (x * x))) / x))); end
code[x_] := N[Log[N[(N[(1.0 / x), $MachinePrecision] + N[(N[Sqrt[N[(1.0 - N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(\frac{1}{x} + \frac{\sqrt{1 - x \cdot x}}{x}\right)
\end{array}
(FPCore (x) :precision binary64 (log (/ (+ 1.0 (sqrt (- 1.0 (* x x)))) x)))
double code(double x) {
return log(((1.0 + sqrt((1.0 - (x * x)))) / x));
}
real(8) function code(x)
real(8), intent (in) :: x
code = log(((1.0d0 + sqrt((1.0d0 - (x * x)))) / x))
end function
public static double code(double x) {
return Math.log(((1.0 + Math.sqrt((1.0 - (x * x)))) / x));
}
def code(x): return math.log(((1.0 + math.sqrt((1.0 - (x * x)))) / x))
function code(x) return log(Float64(Float64(1.0 + sqrt(Float64(1.0 - Float64(x * x)))) / x)) end
function tmp = code(x) tmp = log(((1.0 + sqrt((1.0 - (x * x)))) / x)); end
code[x_] := N[Log[N[(N[(1.0 + N[Sqrt[N[(1.0 - N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(\frac{1 + \sqrt{1 - x \cdot x}}{x}\right)
\end{array}
Initial program 100.0%
div-invN/A
distribute-rgt1-inN/A
un-div-invN/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
rem-square-sqrtN/A
sqrt-lowering-sqrt.f64N/A
rem-square-sqrtN/A
--lowering--.f64N/A
*-lowering-*.f64100.0
Applied egg-rr100.0%
(FPCore (x) :precision binary64 (- (log (/ 1.0 (fma x -0.5 (/ 2.0 x))))))
double code(double x) {
return -log((1.0 / fma(x, -0.5, (2.0 / x))));
}
function code(x) return Float64(-log(Float64(1.0 / fma(x, -0.5, Float64(2.0 / x))))) end
code[x_] := (-N[Log[N[(1.0 / N[(x * -0.5 + N[(2.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])
\begin{array}{l}
\\
-\log \left(\frac{1}{\mathsf{fma}\left(x, -0.5, \frac{2}{x}\right)}\right)
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
distribute-rgt-neg-inN/A
metadata-evalN/A
*-lowering-*.f6499.4
Simplified99.4%
frac-2negN/A
div-invN/A
*-lowering-*.f64N/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
div-invN/A
distribute-neg-frac2N/A
distribute-frac-negN/A
frac-2negN/A
accelerator-lowering-fma.f64N/A
div-invN/A
metadata-evalN/A
*-lowering-*.f64N/A
metadata-evalN/A
frac-2negN/A
metadata-evalN/A
remove-double-negN/A
/-lowering-/.f6499.4
Applied egg-rr99.4%
Taylor expanded in x around inf
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r/N/A
metadata-evalN/A
associate-*r/N/A
unpow2N/A
times-fracN/A
*-inversesN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6499.4
Simplified99.4%
flip-+N/A
clear-numN/A
log-recN/A
neg-lowering-neg.f64N/A
log-lowering-log.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6499.4
Applied egg-rr99.4%
(FPCore (x) :precision binary64 (log (fma x -0.5 (/ 2.0 x))))
double code(double x) {
return log(fma(x, -0.5, (2.0 / x)));
}
function code(x) return log(fma(x, -0.5, Float64(2.0 / x))) end
code[x_] := N[Log[N[(x * -0.5 + N[(2.0 / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\log \left(\mathsf{fma}\left(x, -0.5, \frac{2}{x}\right)\right)
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
/-lowering-/.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
distribute-rgt-neg-inN/A
metadata-evalN/A
*-lowering-*.f6499.4
Simplified99.4%
frac-2negN/A
div-invN/A
*-lowering-*.f64N/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
div-invN/A
distribute-neg-frac2N/A
distribute-frac-negN/A
frac-2negN/A
accelerator-lowering-fma.f64N/A
div-invN/A
metadata-evalN/A
*-lowering-*.f64N/A
metadata-evalN/A
frac-2negN/A
metadata-evalN/A
remove-double-negN/A
/-lowering-/.f6499.4
Applied egg-rr99.4%
Taylor expanded in x around inf
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r/N/A
metadata-evalN/A
associate-*r/N/A
unpow2N/A
times-fracN/A
*-inversesN/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f6499.4
Simplified99.4%
(FPCore (x) :precision binary64 (- (log (* x 0.5))))
double code(double x) {
return -log((x * 0.5));
}
real(8) function code(x)
real(8), intent (in) :: x
code = -log((x * 0.5d0))
end function
public static double code(double x) {
return -Math.log((x * 0.5));
}
def code(x): return -math.log((x * 0.5))
function code(x) return Float64(-log(Float64(x * 0.5))) end
function tmp = code(x) tmp = -log((x * 0.5)); end
code[x_] := (-N[Log[N[(x * 0.5), $MachinePrecision]], $MachinePrecision])
\begin{array}{l}
\\
-\log \left(x \cdot 0.5\right)
\end{array}
Initial program 100.0%
Taylor expanded in x around 0
/-lowering-/.f6498.9
Simplified98.9%
clear-numN/A
log-recN/A
neg-lowering-neg.f64N/A
log-lowering-log.f64N/A
div-invN/A
metadata-evalN/A
*-lowering-*.f6498.9
Applied egg-rr98.9%
(FPCore (x) :precision binary64 (* 0.5 (log -1.0)))
double code(double x) {
return 0.5 * log(-1.0);
}
real(8) function code(x)
real(8), intent (in) :: x
code = 0.5d0 * log((-1.0d0))
end function
public static double code(double x) {
return 0.5 * Math.log(-1.0);
}
def code(x): return 0.5 * math.log(-1.0)
function code(x) return Float64(0.5 * log(-1.0)) end
function tmp = code(x) tmp = 0.5 * log(-1.0); end
code[x_] := N[(0.5 * N[Log[-1.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \log -1
\end{array}
Initial program 100.0%
Taylor expanded in x around inf
sqrt-lowering-sqrt.f640.0
Simplified0.0%
pow1/2N/A
pow-to-expN/A
rem-log-expN/A
*-lowering-*.f64N/A
log-lowering-log.f640.0
Applied egg-rr0.0%
Final simplification0.0%
herbie shell --seed 2024205
(FPCore (x)
:name "Hyperbolic arc-(co)secant"
:precision binary64
(log (+ (/ 1.0 x) (/ (sqrt (- 1.0 (* x x))) x))))