
(FPCore (x) :precision binary64 (copysign (log (+ (fabs x) (sqrt (+ (* x x) 1.0)))) x))
double code(double x) {
return copysign(log((fabs(x) + sqrt(((x * x) + 1.0)))), x);
}
public static double code(double x) {
return Math.copySign(Math.log((Math.abs(x) + Math.sqrt(((x * x) + 1.0)))), x);
}
def code(x): return math.copysign(math.log((math.fabs(x) + math.sqrt(((x * x) + 1.0)))), x)
function code(x) return copysign(log(Float64(abs(x) + sqrt(Float64(Float64(x * x) + 1.0)))), x) end
function tmp = code(x) tmp = sign(x) * abs(log((abs(x) + sqrt(((x * x) + 1.0))))); end
code[x_] := N[With[{TMP1 = Abs[N[Log[N[(N[Abs[x], $MachinePrecision] + N[Sqrt[N[(N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{copysign}\left(\log \left(\left|x\right| + \sqrt{x \cdot x + 1}\right), x\right)
\end{array}
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (copysign (log (+ (fabs x) (sqrt (+ (* x x) 1.0)))) x))
double code(double x) {
return copysign(log((fabs(x) + sqrt(((x * x) + 1.0)))), x);
}
public static double code(double x) {
return Math.copySign(Math.log((Math.abs(x) + Math.sqrt(((x * x) + 1.0)))), x);
}
def code(x): return math.copysign(math.log((math.fabs(x) + math.sqrt(((x * x) + 1.0)))), x)
function code(x) return copysign(log(Float64(abs(x) + sqrt(Float64(Float64(x * x) + 1.0)))), x) end
function tmp = code(x) tmp = sign(x) * abs(log((abs(x) + sqrt(((x * x) + 1.0))))); end
code[x_] := N[With[{TMP1 = Abs[N[Log[N[(N[Abs[x], $MachinePrecision] + N[Sqrt[N[(N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{copysign}\left(\log \left(\left|x\right| + \sqrt{x \cdot x + 1}\right), x\right)
\end{array}
(FPCore (x) :precision binary64 (copysign (asinh x) x))
double code(double x) {
return copysign(asinh(x), x);
}
def code(x): return math.copysign(math.asinh(x), x)
function code(x) return copysign(asinh(x), x) end
function tmp = code(x) tmp = sign(x) * abs(asinh(x)); end
code[x_] := N[With[{TMP1 = Abs[N[ArcSinh[x], $MachinePrecision]], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{copysign}\left(\sinh^{-1} x, x\right)
\end{array}
Initial program 31.3%
lift-log.f64N/A
lift-+.f64N/A
lift-fabs.f64N/A
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
pow2N/A
+-commutativeN/A
+-commutativeN/A
pow2N/A
sqr-abs-revN/A
asinh-def-revN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
lower-asinh.f6499.8
Applied rewrites99.8%
(FPCore (x)
:precision binary64
(copysign
(*
(fma
(-
(* (fma -0.044642857142857144 (* x x) 0.075) (* x x))
0.16666666666666666)
(* x x)
1.0)
x)
x))
double code(double x) {
return copysign((fma(((fma(-0.044642857142857144, (x * x), 0.075) * (x * x)) - 0.16666666666666666), (x * x), 1.0) * x), x);
}
function code(x) return copysign(Float64(fma(Float64(Float64(fma(-0.044642857142857144, Float64(x * x), 0.075) * Float64(x * x)) - 0.16666666666666666), Float64(x * x), 1.0) * x), x) end
code[x_] := N[With[{TMP1 = Abs[N[(N[(N[(N[(N[(-0.044642857142857144 * N[(x * x), $MachinePrecision] + 0.075), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] - 0.16666666666666666), $MachinePrecision] * N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision] * x), $MachinePrecision]], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{copysign}\left(\mathsf{fma}\left(\mathsf{fma}\left(-0.044642857142857144, x \cdot x, 0.075\right) \cdot \left(x \cdot x\right) - 0.16666666666666666, x \cdot x, 1\right) \cdot x, x\right)
\end{array}
Initial program 31.3%
lift-log.f64N/A
lift-+.f64N/A
lift-fabs.f64N/A
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
pow2N/A
+-commutativeN/A
+-commutativeN/A
pow2N/A
sqr-abs-revN/A
asinh-def-revN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
lower-asinh.f6499.8
Applied rewrites99.8%
Taylor expanded in x around 0
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
asinh-def-revN/A
sqr-abs-revN/A
pow2N/A
+-commutativeN/A
+-commutativeN/A
pow2N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.4%
(FPCore (x) :precision binary64 (copysign (* (fma (- (* 0.075 (* x x)) 0.16666666666666666) (* x x) 1.0) x) x))
double code(double x) {
return copysign((fma(((0.075 * (x * x)) - 0.16666666666666666), (x * x), 1.0) * x), x);
}
function code(x) return copysign(Float64(fma(Float64(Float64(0.075 * Float64(x * x)) - 0.16666666666666666), Float64(x * x), 1.0) * x), x) end
code[x_] := N[With[{TMP1 = Abs[N[(N[(N[(N[(0.075 * N[(x * x), $MachinePrecision]), $MachinePrecision] - 0.16666666666666666), $MachinePrecision] * N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision] * x), $MachinePrecision]], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{copysign}\left(\mathsf{fma}\left(0.075 \cdot \left(x \cdot x\right) - 0.16666666666666666, x \cdot x, 1\right) \cdot x, x\right)
\end{array}
Initial program 31.3%
lift-log.f64N/A
lift-+.f64N/A
lift-fabs.f64N/A
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
pow2N/A
+-commutativeN/A
+-commutativeN/A
pow2N/A
sqr-abs-revN/A
asinh-def-revN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
lower-asinh.f6499.8
Applied rewrites99.8%
Taylor expanded in x around 0
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
asinh-def-revN/A
sqr-abs-revN/A
pow2N/A
+-commutativeN/A
+-commutativeN/A
pow2N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.4%
(FPCore (x) :precision binary64 (copysign (* (fma -0.16666666666666666 (* x x) 1.0) x) x))
double code(double x) {
return copysign((fma(-0.16666666666666666, (x * x), 1.0) * x), x);
}
function code(x) return copysign(Float64(fma(-0.16666666666666666, Float64(x * x), 1.0) * x), x) end
code[x_] := N[With[{TMP1 = Abs[N[(N[(-0.16666666666666666 * N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision] * x), $MachinePrecision]], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{copysign}\left(\mathsf{fma}\left(-0.16666666666666666, x \cdot x, 1\right) \cdot x, x\right)
\end{array}
Initial program 31.3%
lift-log.f64N/A
lift-+.f64N/A
lift-fabs.f64N/A
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
pow2N/A
+-commutativeN/A
+-commutativeN/A
pow2N/A
sqr-abs-revN/A
asinh-def-revN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
lower-asinh.f6499.8
Applied rewrites99.8%
Taylor expanded in x around 0
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
asinh-def-revN/A
sqr-abs-revN/A
pow2N/A
+-commutativeN/A
+-commutativeN/A
pow2N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
pow2N/A
lift-*.f6451.5
Applied rewrites51.5%
(FPCore (x) :precision binary64 (copysign x x))
double code(double x) {
return copysign(x, x);
}
public static double code(double x) {
return Math.copySign(x, x);
}
def code(x): return math.copysign(x, x)
function code(x) return copysign(x, x) end
function tmp = code(x) tmp = sign(x) * abs(x); end
code[x_] := N[With[{TMP1 = Abs[x], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
\begin{array}{l}
\\
\mathsf{copysign}\left(x, x\right)
\end{array}
Initial program 31.3%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites50.5%
Taylor expanded in x around 0
Applied rewrites52.1%
(FPCore (x) :precision binary64 (let* ((t_0 (/ 1.0 (fabs x)))) (copysign (log1p (+ (fabs x) (/ (fabs x) (+ (hypot 1.0 t_0) t_0)))) x)))
double code(double x) {
double t_0 = 1.0 / fabs(x);
return copysign(log1p((fabs(x) + (fabs(x) / (hypot(1.0, t_0) + t_0)))), x);
}
public static double code(double x) {
double t_0 = 1.0 / Math.abs(x);
return Math.copySign(Math.log1p((Math.abs(x) + (Math.abs(x) / (Math.hypot(1.0, t_0) + t_0)))), x);
}
def code(x): t_0 = 1.0 / math.fabs(x) return math.copysign(math.log1p((math.fabs(x) + (math.fabs(x) / (math.hypot(1.0, t_0) + t_0)))), x)
function code(x) t_0 = Float64(1.0 / abs(x)) return copysign(log1p(Float64(abs(x) + Float64(abs(x) / Float64(hypot(1.0, t_0) + t_0)))), x) end
code[x_] := Block[{t$95$0 = N[(1.0 / N[Abs[x], $MachinePrecision]), $MachinePrecision]}, N[With[{TMP1 = Abs[N[Log[1 + N[(N[Abs[x], $MachinePrecision] + N[(N[Abs[x], $MachinePrecision] / N[(N[Sqrt[1.0 ^ 2 + t$95$0 ^ 2], $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{\left|x\right|}\\
\mathsf{copysign}\left(\mathsf{log1p}\left(\left|x\right| + \frac{\left|x\right|}{\mathsf{hypot}\left(1, t\_0\right) + t\_0}\right), x\right)
\end{array}
\end{array}
herbie shell --seed 2025101
(FPCore (x)
:name "Rust f64::asinh"
:precision binary64
:alt
(! :herbie-platform default (let* ((ax (fabs x)) (ix (/ 1 ax))) (copysign (log1p (+ ax (/ ax (+ (hypot 1 ix) ix)))) x)))
(copysign (log (+ (fabs x) (sqrt (+ (* x x) 1.0)))) x))