
(FPCore (x) :precision binary64 (* (/ 1.0 2.0) (log (/ (+ 1.0 x) (- 1.0 x)))))
double code(double x) {
return (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = (1.0d0 / 2.0d0) * log(((1.0d0 + x) / (1.0d0 - x)))
end function
public static double code(double x) {
return (1.0 / 2.0) * Math.log(((1.0 + x) / (1.0 - x)));
}
def code(x): return (1.0 / 2.0) * math.log(((1.0 + x) / (1.0 - x)))
function code(x) return Float64(Float64(1.0 / 2.0) * log(Float64(Float64(1.0 + x) / Float64(1.0 - x)))) end
function tmp = code(x) tmp = (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x))); end
code[x_] := N[(N[(1.0 / 2.0), $MachinePrecision] * N[Log[N[(N[(1.0 + x), $MachinePrecision] / N[(1.0 - x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - x}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 4 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (* (/ 1.0 2.0) (log (/ (+ 1.0 x) (- 1.0 x)))))
double code(double x) {
return (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = (1.0d0 / 2.0d0) * log(((1.0d0 + x) / (1.0d0 - x)))
end function
public static double code(double x) {
return (1.0 / 2.0) * Math.log(((1.0 + x) / (1.0 - x)));
}
def code(x): return (1.0 / 2.0) * math.log(((1.0 + x) / (1.0 - x)))
function code(x) return Float64(Float64(1.0 / 2.0) * log(Float64(Float64(1.0 + x) / Float64(1.0 - x)))) end
function tmp = code(x) tmp = (1.0 / 2.0) * log(((1.0 + x) / (1.0 - x))); end
code[x_] := N[(N[(1.0 / 2.0), $MachinePrecision] * N[Log[N[(N[(1.0 + x), $MachinePrecision] / N[(1.0 - x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{2} \cdot \log \left(\frac{1 + x}{1 - x}\right)
\end{array}
(FPCore (x) :precision binary64 (* 0.5 (- (log1p x) (log1p (- x)))))
double code(double x) {
return 0.5 * (log1p(x) - log1p(-x));
}
public static double code(double x) {
return 0.5 * (Math.log1p(x) - Math.log1p(-x));
}
def code(x): return 0.5 * (math.log1p(x) - math.log1p(-x))
function code(x) return Float64(0.5 * Float64(log1p(x) - log1p(Float64(-x)))) end
code[x_] := N[(0.5 * N[(N[Log[1 + x], $MachinePrecision] - N[Log[1 + (-x)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(\mathsf{log1p}\left(x\right) - \mathsf{log1p}\left(-x\right)\right)
\end{array}
Initial program 8.9%
metadata-eval8.9%
log-div9.0%
log1p-def21.3%
sub-neg21.3%
log1p-def100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (x) :precision binary64 (* 0.5 (+ (* x 2.0) (* 0.6666666666666666 (pow x 3.0)))))
double code(double x) {
return 0.5 * ((x * 2.0) + (0.6666666666666666 * pow(x, 3.0)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = 0.5d0 * ((x * 2.0d0) + (0.6666666666666666d0 * (x ** 3.0d0)))
end function
public static double code(double x) {
return 0.5 * ((x * 2.0) + (0.6666666666666666 * Math.pow(x, 3.0)));
}
def code(x): return 0.5 * ((x * 2.0) + (0.6666666666666666 * math.pow(x, 3.0)))
function code(x) return Float64(0.5 * Float64(Float64(x * 2.0) + Float64(0.6666666666666666 * (x ^ 3.0)))) end
function tmp = code(x) tmp = 0.5 * ((x * 2.0) + (0.6666666666666666 * (x ^ 3.0))); end
code[x_] := N[(0.5 * N[(N[(x * 2.0), $MachinePrecision] + N[(0.6666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(x \cdot 2 + 0.6666666666666666 \cdot {x}^{3}\right)
\end{array}
Initial program 8.9%
metadata-eval8.9%
Simplified8.9%
Taylor expanded in x around 0 99.4%
Final simplification99.4%
(FPCore (x) :precision binary64 (* 0.5 (* x 2.0)))
double code(double x) {
return 0.5 * (x * 2.0);
}
real(8) function code(x)
real(8), intent (in) :: x
code = 0.5d0 * (x * 2.0d0)
end function
public static double code(double x) {
return 0.5 * (x * 2.0);
}
def code(x): return 0.5 * (x * 2.0)
function code(x) return Float64(0.5 * Float64(x * 2.0)) end
function tmp = code(x) tmp = 0.5 * (x * 2.0); end
code[x_] := N[(0.5 * N[(x * 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \left(x \cdot 2\right)
\end{array}
Initial program 8.9%
metadata-eval8.9%
Simplified8.9%
Taylor expanded in x around 0 99.1%
Final simplification99.1%
(FPCore (x) :precision binary64 0.0)
double code(double x) {
return 0.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = 0.0d0
end function
public static double code(double x) {
return 0.0;
}
def code(x): return 0.0
function code(x) return 0.0 end
function tmp = code(x) tmp = 0.0; end
code[x_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 8.9%
metadata-eval8.9%
Simplified8.9%
div-inv9.0%
add-cube-cbrt8.8%
associate-*l*8.8%
pow28.8%
frac-2neg8.8%
metadata-eval8.8%
sub-neg8.8%
add-sqr-sqrt4.9%
sqrt-unprod7.8%
sqr-neg7.8%
sqrt-unprod2.9%
add-sqr-sqrt5.6%
*-un-lft-identity5.6%
*-un-lft-identity5.6%
+-commutative5.6%
distribute-neg-in5.6%
add-sqr-sqrt2.6%
sqrt-unprod6.5%
sqr-neg6.5%
sqrt-unprod3.9%
add-sqr-sqrt8.8%
metadata-eval8.8%
Applied egg-rr8.8%
associate-*r*8.8%
unpow28.8%
add-cube-cbrt9.0%
add-sqr-sqrt8.9%
associate-*r*8.9%
log-prod8.9%
Applied egg-rr8.8%
log-prod8.8%
log1p-def21.1%
associate-+l+21.1%
log-rec21.1%
neg-mul-121.1%
log-rec21.1%
neg-mul-121.1%
distribute-rgt-out21.1%
metadata-eval21.1%
Simplified21.1%
add-cbrt-cube21.1%
pow1/321.1%
log-pow21.2%
add-sqr-sqrt21.3%
pow121.3%
pow1/221.3%
pow-prod-up21.2%
log-pow21.3%
metadata-eval21.3%
sub-neg21.3%
log1p-def99.6%
Applied egg-rr99.6%
expm1-log1p-u99.2%
expm1-udef8.7%
Applied egg-rr5.2%
expm1-def5.2%
expm1-log1p5.2%
fma-udef5.2%
distribute-lft1-in5.2%
metadata-eval5.2%
mul0-lft5.2%
Simplified5.2%
Final simplification5.2%
herbie shell --seed 2023230
(FPCore (x)
:name "Hyperbolic arc-(co)tangent"
:precision binary64
(* (/ 1.0 2.0) (log (/ (+ 1.0 x) (- 1.0 x)))))