
(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}
Sampling outcomes in binary64 precision:
Herbie found 11 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
(if (<= x -0.022)
(- (log (- (hypot 1.0 x) x)))
(if (<= x 0.02)
(+
x
(+
(* -0.16666666666666666 (pow x 3.0))
(+ (* -0.044642857142857144 (pow x 7.0)) (* 0.075 (pow x 5.0)))))
(log (+ x (hypot 1.0 x))))))
double code(double x) {
double tmp;
if (x <= -0.022) {
tmp = -log((hypot(1.0, x) - x));
} else if (x <= 0.02) {
tmp = x + ((-0.16666666666666666 * pow(x, 3.0)) + ((-0.044642857142857144 * pow(x, 7.0)) + (0.075 * pow(x, 5.0))));
} else {
tmp = log((x + hypot(1.0, x)));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -0.022) {
tmp = -Math.log((Math.hypot(1.0, x) - x));
} else if (x <= 0.02) {
tmp = x + ((-0.16666666666666666 * Math.pow(x, 3.0)) + ((-0.044642857142857144 * Math.pow(x, 7.0)) + (0.075 * Math.pow(x, 5.0))));
} else {
tmp = Math.log((x + Math.hypot(1.0, x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.022: tmp = -math.log((math.hypot(1.0, x) - x)) elif x <= 0.02: tmp = x + ((-0.16666666666666666 * math.pow(x, 3.0)) + ((-0.044642857142857144 * math.pow(x, 7.0)) + (0.075 * math.pow(x, 5.0)))) else: tmp = math.log((x + math.hypot(1.0, x))) return tmp
function code(x) tmp = 0.0 if (x <= -0.022) tmp = Float64(-log(Float64(hypot(1.0, x) - x))); elseif (x <= 0.02) tmp = Float64(x + Float64(Float64(-0.16666666666666666 * (x ^ 3.0)) + Float64(Float64(-0.044642857142857144 * (x ^ 7.0)) + Float64(0.075 * (x ^ 5.0))))); else tmp = log(Float64(x + hypot(1.0, x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.022) tmp = -log((hypot(1.0, x) - x)); elseif (x <= 0.02) tmp = x + ((-0.16666666666666666 * (x ^ 3.0)) + ((-0.044642857142857144 * (x ^ 7.0)) + (0.075 * (x ^ 5.0)))); else tmp = log((x + hypot(1.0, x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.022], (-N[Log[N[(N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision] - x), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.02], N[(x + N[(N[(-0.16666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(-0.044642857142857144 * N[Power[x, 7.0], $MachinePrecision]), $MachinePrecision] + N[(0.075 * N[Power[x, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Log[N[(x + N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.022:\\
\;\;\;\;-\log \left(\mathsf{hypot}\left(1, x\right) - x\right)\\
\mathbf{elif}\;x \leq 0.02:\\
\;\;\;\;x + \left(-0.16666666666666666 \cdot {x}^{3} + \left(-0.044642857142857144 \cdot {x}^{7} + 0.075 \cdot {x}^{5}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\log \left(x + \mathsf{hypot}\left(1, x\right)\right)\\
\end{array}
\end{array}
if x < -0.021999999999999999Initial program 5.7%
sqr-neg5.7%
+-commutative5.7%
sqr-neg5.7%
hypot-1-def6.7%
Simplified6.7%
flip-+6.6%
frac-2neg6.6%
log-div6.6%
pow26.6%
hypot-1-def6.6%
hypot-1-def6.6%
add-sqr-sqrt6.6%
+-commutative6.6%
fma-def6.6%
Applied egg-rr6.6%
neg-sub06.6%
associate--r-6.6%
neg-sub06.6%
+-commutative6.6%
sub-neg6.6%
fma-udef6.6%
unpow26.6%
+-commutative6.6%
associate--l+59.7%
+-inverses100.0%
metadata-eval100.0%
metadata-eval100.0%
neg-sub0100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
if -0.021999999999999999 < x < 0.0200000000000000004Initial program 11.4%
sqr-neg11.4%
+-commutative11.4%
sqr-neg11.4%
hypot-1-def11.5%
Simplified11.5%
Taylor expanded in x around 0 100.0%
if 0.0200000000000000004 < x Initial program 53.0%
sqr-neg53.0%
+-commutative53.0%
sqr-neg53.0%
hypot-1-def100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (x)
:precision binary64
(if (<= x -0.006)
(- (log (- (hypot 1.0 x) x)))
(if (<= x 0.008)
(+ x (+ (* -0.16666666666666666 (pow x 3.0)) (* 0.075 (pow x 5.0))))
(log (+ x (hypot 1.0 x))))))
double code(double x) {
double tmp;
if (x <= -0.006) {
tmp = -log((hypot(1.0, x) - x));
} else if (x <= 0.008) {
tmp = x + ((-0.16666666666666666 * pow(x, 3.0)) + (0.075 * pow(x, 5.0)));
} else {
tmp = log((x + hypot(1.0, x)));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -0.006) {
tmp = -Math.log((Math.hypot(1.0, x) - x));
} else if (x <= 0.008) {
tmp = x + ((-0.16666666666666666 * Math.pow(x, 3.0)) + (0.075 * Math.pow(x, 5.0)));
} else {
tmp = Math.log((x + Math.hypot(1.0, x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.006: tmp = -math.log((math.hypot(1.0, x) - x)) elif x <= 0.008: tmp = x + ((-0.16666666666666666 * math.pow(x, 3.0)) + (0.075 * math.pow(x, 5.0))) else: tmp = math.log((x + math.hypot(1.0, x))) return tmp
function code(x) tmp = 0.0 if (x <= -0.006) tmp = Float64(-log(Float64(hypot(1.0, x) - x))); elseif (x <= 0.008) tmp = Float64(x + Float64(Float64(-0.16666666666666666 * (x ^ 3.0)) + Float64(0.075 * (x ^ 5.0)))); else tmp = log(Float64(x + hypot(1.0, x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.006) tmp = -log((hypot(1.0, x) - x)); elseif (x <= 0.008) tmp = x + ((-0.16666666666666666 * (x ^ 3.0)) + (0.075 * (x ^ 5.0))); else tmp = log((x + hypot(1.0, x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.006], (-N[Log[N[(N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision] - x), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.008], N[(x + N[(N[(-0.16666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision] + N[(0.075 * N[Power[x, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Log[N[(x + N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.006:\\
\;\;\;\;-\log \left(\mathsf{hypot}\left(1, x\right) - x\right)\\
\mathbf{elif}\;x \leq 0.008:\\
\;\;\;\;x + \left(-0.16666666666666666 \cdot {x}^{3} + 0.075 \cdot {x}^{5}\right)\\
\mathbf{else}:\\
\;\;\;\;\log \left(x + \mathsf{hypot}\left(1, x\right)\right)\\
\end{array}
\end{array}
if x < -0.0060000000000000001Initial program 8.4%
sqr-neg8.4%
+-commutative8.4%
sqr-neg8.4%
hypot-1-def9.4%
Simplified9.4%
flip-+9.2%
frac-2neg9.2%
log-div9.3%
pow29.3%
hypot-1-def9.3%
hypot-1-def9.3%
add-sqr-sqrt9.3%
+-commutative9.3%
fma-def9.3%
Applied egg-rr9.3%
neg-sub09.3%
associate--r-9.3%
neg-sub09.3%
+-commutative9.3%
sub-neg9.3%
fma-udef9.3%
unpow29.3%
+-commutative9.3%
associate--l+60.8%
+-inverses99.9%
metadata-eval99.9%
metadata-eval99.9%
neg-sub099.9%
neg-sub099.9%
associate--r-99.9%
neg-sub099.9%
+-commutative99.9%
sub-neg99.9%
Simplified99.9%
if -0.0060000000000000001 < x < 0.0080000000000000002Initial program 10.1%
sqr-neg10.1%
+-commutative10.1%
sqr-neg10.1%
hypot-1-def10.2%
Simplified10.2%
Taylor expanded in x around 0 100.0%
if 0.0080000000000000002 < x Initial program 53.0%
sqr-neg53.0%
+-commutative53.0%
sqr-neg53.0%
hypot-1-def100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (x)
:precision binary64
(if (<= x -0.95)
(- (log (- (* x -2.0) (/ 0.5 x))))
(if (<= x 0.00095)
(+ x (* -0.16666666666666666 (pow x 3.0)))
(log (+ x (hypot 1.0 x))))))
double code(double x) {
double tmp;
if (x <= -0.95) {
tmp = -log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.00095) {
tmp = x + (-0.16666666666666666 * pow(x, 3.0));
} else {
tmp = log((x + hypot(1.0, x)));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -0.95) {
tmp = -Math.log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.00095) {
tmp = x + (-0.16666666666666666 * Math.pow(x, 3.0));
} else {
tmp = Math.log((x + Math.hypot(1.0, x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.95: tmp = -math.log(((x * -2.0) - (0.5 / x))) elif x <= 0.00095: tmp = x + (-0.16666666666666666 * math.pow(x, 3.0)) else: tmp = math.log((x + math.hypot(1.0, x))) return tmp
function code(x) tmp = 0.0 if (x <= -0.95) tmp = Float64(-log(Float64(Float64(x * -2.0) - Float64(0.5 / x)))); elseif (x <= 0.00095) tmp = Float64(x + Float64(-0.16666666666666666 * (x ^ 3.0))); else tmp = log(Float64(x + hypot(1.0, x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.95) tmp = -log(((x * -2.0) - (0.5 / x))); elseif (x <= 0.00095) tmp = x + (-0.16666666666666666 * (x ^ 3.0)); else tmp = log((x + hypot(1.0, x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.95], (-N[Log[N[(N[(x * -2.0), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.00095], N[(x + N[(-0.16666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Log[N[(x + N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.95:\\
\;\;\;\;-\log \left(x \cdot -2 - \frac{0.5}{x}\right)\\
\mathbf{elif}\;x \leq 0.00095:\\
\;\;\;\;x + -0.16666666666666666 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;\log \left(x + \mathsf{hypot}\left(1, x\right)\right)\\
\end{array}
\end{array}
if x < -0.94999999999999996Initial program 5.7%
sqr-neg5.7%
+-commutative5.7%
sqr-neg5.7%
hypot-1-def6.7%
Simplified6.7%
flip-+6.6%
frac-2neg6.6%
log-div6.6%
pow26.6%
hypot-1-def6.6%
hypot-1-def6.6%
add-sqr-sqrt6.6%
+-commutative6.6%
fma-def6.6%
Applied egg-rr6.6%
neg-sub06.6%
associate--r-6.6%
neg-sub06.6%
+-commutative6.6%
sub-neg6.6%
fma-udef6.6%
unpow26.6%
+-commutative6.6%
associate--l+59.7%
+-inverses100.0%
metadata-eval100.0%
metadata-eval100.0%
neg-sub0100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in x around -inf 99.4%
*-commutative99.4%
associate-*r/99.4%
metadata-eval99.4%
Simplified99.4%
if -0.94999999999999996 < x < 9.49999999999999998e-4Initial program 11.4%
sqr-neg11.4%
+-commutative11.4%
sqr-neg11.4%
hypot-1-def11.5%
Simplified11.5%
Taylor expanded in x around 0 99.2%
if 9.49999999999999998e-4 < x Initial program 53.0%
sqr-neg53.0%
+-commutative53.0%
sqr-neg53.0%
hypot-1-def100.0%
Simplified100.0%
Final simplification99.5%
(FPCore (x)
:precision binary64
(if (<= x -0.00096)
(- (log (- (hypot 1.0 x) x)))
(if (<= x 0.00095)
(+ x (* -0.16666666666666666 (pow x 3.0)))
(log (+ x (hypot 1.0 x))))))
double code(double x) {
double tmp;
if (x <= -0.00096) {
tmp = -log((hypot(1.0, x) - x));
} else if (x <= 0.00095) {
tmp = x + (-0.16666666666666666 * pow(x, 3.0));
} else {
tmp = log((x + hypot(1.0, x)));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -0.00096) {
tmp = -Math.log((Math.hypot(1.0, x) - x));
} else if (x <= 0.00095) {
tmp = x + (-0.16666666666666666 * Math.pow(x, 3.0));
} else {
tmp = Math.log((x + Math.hypot(1.0, x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.00096: tmp = -math.log((math.hypot(1.0, x) - x)) elif x <= 0.00095: tmp = x + (-0.16666666666666666 * math.pow(x, 3.0)) else: tmp = math.log((x + math.hypot(1.0, x))) return tmp
function code(x) tmp = 0.0 if (x <= -0.00096) tmp = Float64(-log(Float64(hypot(1.0, x) - x))); elseif (x <= 0.00095) tmp = Float64(x + Float64(-0.16666666666666666 * (x ^ 3.0))); else tmp = log(Float64(x + hypot(1.0, x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.00096) tmp = -log((hypot(1.0, x) - x)); elseif (x <= 0.00095) tmp = x + (-0.16666666666666666 * (x ^ 3.0)); else tmp = log((x + hypot(1.0, x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.00096], (-N[Log[N[(N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision] - x), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.00095], N[(x + N[(-0.16666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Log[N[(x + N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.00096:\\
\;\;\;\;-\log \left(\mathsf{hypot}\left(1, x\right) - x\right)\\
\mathbf{elif}\;x \leq 0.00095:\\
\;\;\;\;x + -0.16666666666666666 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;\log \left(x + \mathsf{hypot}\left(1, x\right)\right)\\
\end{array}
\end{array}
if x < -9.60000000000000024e-4Initial program 9.6%
sqr-neg9.6%
+-commutative9.6%
sqr-neg9.6%
hypot-1-def10.6%
Simplified10.6%
flip-+10.5%
frac-2neg10.5%
log-div10.6%
pow210.6%
hypot-1-def10.6%
hypot-1-def10.6%
add-sqr-sqrt10.6%
+-commutative10.6%
fma-def10.6%
Applied egg-rr10.6%
neg-sub010.6%
associate--r-10.6%
neg-sub010.6%
+-commutative10.6%
sub-neg10.6%
fma-udef10.6%
unpow210.6%
+-commutative10.6%
associate--l+61.3%
+-inverses99.8%
metadata-eval99.8%
metadata-eval99.8%
neg-sub099.8%
neg-sub099.8%
associate--r-99.8%
neg-sub099.8%
+-commutative99.8%
sub-neg99.8%
Simplified99.8%
if -9.60000000000000024e-4 < x < 9.49999999999999998e-4Initial program 9.5%
sqr-neg9.5%
+-commutative9.5%
sqr-neg9.5%
hypot-1-def9.6%
Simplified9.6%
Taylor expanded in x around 0 100.0%
if 9.49999999999999998e-4 < x Initial program 53.0%
sqr-neg53.0%
+-commutative53.0%
sqr-neg53.0%
hypot-1-def100.0%
Simplified100.0%
Final simplification99.9%
(FPCore (x)
:precision binary64
(if (<= x -0.95)
(- (log (- (* x -2.0) (/ 0.5 x))))
(if (<= x 0.95)
(+ x (* -0.16666666666666666 (pow x 3.0)))
(log (+ (* x 2.0) (* 0.5 (/ 1.0 x)))))))
double code(double x) {
double tmp;
if (x <= -0.95) {
tmp = -log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.95) {
tmp = x + (-0.16666666666666666 * pow(x, 3.0));
} else {
tmp = log(((x * 2.0) + (0.5 * (1.0 / x))));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-0.95d0)) then
tmp = -log(((x * (-2.0d0)) - (0.5d0 / x)))
else if (x <= 0.95d0) then
tmp = x + ((-0.16666666666666666d0) * (x ** 3.0d0))
else
tmp = log(((x * 2.0d0) + (0.5d0 * (1.0d0 / x))))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -0.95) {
tmp = -Math.log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.95) {
tmp = x + (-0.16666666666666666 * Math.pow(x, 3.0));
} else {
tmp = Math.log(((x * 2.0) + (0.5 * (1.0 / x))));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.95: tmp = -math.log(((x * -2.0) - (0.5 / x))) elif x <= 0.95: tmp = x + (-0.16666666666666666 * math.pow(x, 3.0)) else: tmp = math.log(((x * 2.0) + (0.5 * (1.0 / x)))) return tmp
function code(x) tmp = 0.0 if (x <= -0.95) tmp = Float64(-log(Float64(Float64(x * -2.0) - Float64(0.5 / x)))); elseif (x <= 0.95) tmp = Float64(x + Float64(-0.16666666666666666 * (x ^ 3.0))); else tmp = log(Float64(Float64(x * 2.0) + Float64(0.5 * Float64(1.0 / x)))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.95) tmp = -log(((x * -2.0) - (0.5 / x))); elseif (x <= 0.95) tmp = x + (-0.16666666666666666 * (x ^ 3.0)); else tmp = log(((x * 2.0) + (0.5 * (1.0 / x)))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.95], (-N[Log[N[(N[(x * -2.0), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.95], N[(x + N[(-0.16666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Log[N[(N[(x * 2.0), $MachinePrecision] + N[(0.5 * N[(1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.95:\\
\;\;\;\;-\log \left(x \cdot -2 - \frac{0.5}{x}\right)\\
\mathbf{elif}\;x \leq 0.95:\\
\;\;\;\;x + -0.16666666666666666 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2 + 0.5 \cdot \frac{1}{x}\right)\\
\end{array}
\end{array}
if x < -0.94999999999999996Initial program 5.7%
sqr-neg5.7%
+-commutative5.7%
sqr-neg5.7%
hypot-1-def6.7%
Simplified6.7%
flip-+6.6%
frac-2neg6.6%
log-div6.6%
pow26.6%
hypot-1-def6.6%
hypot-1-def6.6%
add-sqr-sqrt6.6%
+-commutative6.6%
fma-def6.6%
Applied egg-rr6.6%
neg-sub06.6%
associate--r-6.6%
neg-sub06.6%
+-commutative6.6%
sub-neg6.6%
fma-udef6.6%
unpow26.6%
+-commutative6.6%
associate--l+59.7%
+-inverses100.0%
metadata-eval100.0%
metadata-eval100.0%
neg-sub0100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in x around -inf 99.4%
*-commutative99.4%
associate-*r/99.4%
metadata-eval99.4%
Simplified99.4%
if -0.94999999999999996 < x < 0.94999999999999996Initial program 11.4%
sqr-neg11.4%
+-commutative11.4%
sqr-neg11.4%
hypot-1-def11.5%
Simplified11.5%
Taylor expanded in x around 0 99.2%
if 0.94999999999999996 < x Initial program 53.0%
sqr-neg53.0%
+-commutative53.0%
sqr-neg53.0%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 98.9%
Final simplification99.2%
(FPCore (x)
:precision binary64
(if (<= x -1.25)
(- (log (* x -2.0)))
(if (<= x 1.25)
(+ x (* -0.16666666666666666 (pow x 3.0)))
(log (* x 2.0)))))
double code(double x) {
double tmp;
if (x <= -1.25) {
tmp = -log((x * -2.0));
} else if (x <= 1.25) {
tmp = x + (-0.16666666666666666 * pow(x, 3.0));
} else {
tmp = log((x * 2.0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-1.25d0)) then
tmp = -log((x * (-2.0d0)))
else if (x <= 1.25d0) then
tmp = x + ((-0.16666666666666666d0) * (x ** 3.0d0))
else
tmp = log((x * 2.0d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -1.25) {
tmp = -Math.log((x * -2.0));
} else if (x <= 1.25) {
tmp = x + (-0.16666666666666666 * Math.pow(x, 3.0));
} else {
tmp = Math.log((x * 2.0));
}
return tmp;
}
def code(x): tmp = 0 if x <= -1.25: tmp = -math.log((x * -2.0)) elif x <= 1.25: tmp = x + (-0.16666666666666666 * math.pow(x, 3.0)) else: tmp = math.log((x * 2.0)) return tmp
function code(x) tmp = 0.0 if (x <= -1.25) tmp = Float64(-log(Float64(x * -2.0))); elseif (x <= 1.25) tmp = Float64(x + Float64(-0.16666666666666666 * (x ^ 3.0))); else tmp = log(Float64(x * 2.0)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -1.25) tmp = -log((x * -2.0)); elseif (x <= 1.25) tmp = x + (-0.16666666666666666 * (x ^ 3.0)); else tmp = log((x * 2.0)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -1.25], (-N[Log[N[(x * -2.0), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 1.25], N[(x + N[(-0.16666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Log[N[(x * 2.0), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.25:\\
\;\;\;\;-\log \left(x \cdot -2\right)\\
\mathbf{elif}\;x \leq 1.25:\\
\;\;\;\;x + -0.16666666666666666 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2\right)\\
\end{array}
\end{array}
if x < -1.25Initial program 5.7%
sqr-neg5.7%
+-commutative5.7%
sqr-neg5.7%
hypot-1-def6.7%
Simplified6.7%
flip-+6.6%
frac-2neg6.6%
log-div6.6%
pow26.6%
hypot-1-def6.6%
hypot-1-def6.6%
add-sqr-sqrt6.6%
+-commutative6.6%
fma-def6.6%
Applied egg-rr6.6%
neg-sub06.6%
associate--r-6.6%
neg-sub06.6%
+-commutative6.6%
sub-neg6.6%
fma-udef6.6%
unpow26.6%
+-commutative6.6%
associate--l+59.7%
+-inverses100.0%
metadata-eval100.0%
metadata-eval100.0%
neg-sub0100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in x around -inf 98.1%
*-commutative98.1%
Simplified98.1%
if -1.25 < x < 1.25Initial program 12.1%
sqr-neg12.1%
+-commutative12.1%
sqr-neg12.1%
hypot-1-def12.1%
Simplified12.1%
Taylor expanded in x around 0 98.6%
if 1.25 < x Initial program 52.3%
sqr-neg52.3%
+-commutative52.3%
sqr-neg52.3%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.4%
*-commutative99.4%
Simplified99.4%
Final simplification98.7%
(FPCore (x)
:precision binary64
(if (<= x -0.95)
(- (log (- (* x -2.0) (/ 0.5 x))))
(if (<= x 1.25)
(+ x (* -0.16666666666666666 (pow x 3.0)))
(log (* x 2.0)))))
double code(double x) {
double tmp;
if (x <= -0.95) {
tmp = -log(((x * -2.0) - (0.5 / x)));
} else if (x <= 1.25) {
tmp = x + (-0.16666666666666666 * pow(x, 3.0));
} else {
tmp = log((x * 2.0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-0.95d0)) then
tmp = -log(((x * (-2.0d0)) - (0.5d0 / x)))
else if (x <= 1.25d0) then
tmp = x + ((-0.16666666666666666d0) * (x ** 3.0d0))
else
tmp = log((x * 2.0d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -0.95) {
tmp = -Math.log(((x * -2.0) - (0.5 / x)));
} else if (x <= 1.25) {
tmp = x + (-0.16666666666666666 * Math.pow(x, 3.0));
} else {
tmp = Math.log((x * 2.0));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.95: tmp = -math.log(((x * -2.0) - (0.5 / x))) elif x <= 1.25: tmp = x + (-0.16666666666666666 * math.pow(x, 3.0)) else: tmp = math.log((x * 2.0)) return tmp
function code(x) tmp = 0.0 if (x <= -0.95) tmp = Float64(-log(Float64(Float64(x * -2.0) - Float64(0.5 / x)))); elseif (x <= 1.25) tmp = Float64(x + Float64(-0.16666666666666666 * (x ^ 3.0))); else tmp = log(Float64(x * 2.0)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.95) tmp = -log(((x * -2.0) - (0.5 / x))); elseif (x <= 1.25) tmp = x + (-0.16666666666666666 * (x ^ 3.0)); else tmp = log((x * 2.0)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.95], (-N[Log[N[(N[(x * -2.0), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 1.25], N[(x + N[(-0.16666666666666666 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Log[N[(x * 2.0), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.95:\\
\;\;\;\;-\log \left(x \cdot -2 - \frac{0.5}{x}\right)\\
\mathbf{elif}\;x \leq 1.25:\\
\;\;\;\;x + -0.16666666666666666 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2\right)\\
\end{array}
\end{array}
if x < -0.94999999999999996Initial program 5.7%
sqr-neg5.7%
+-commutative5.7%
sqr-neg5.7%
hypot-1-def6.7%
Simplified6.7%
flip-+6.6%
frac-2neg6.6%
log-div6.6%
pow26.6%
hypot-1-def6.6%
hypot-1-def6.6%
add-sqr-sqrt6.6%
+-commutative6.6%
fma-def6.6%
Applied egg-rr6.6%
neg-sub06.6%
associate--r-6.6%
neg-sub06.6%
+-commutative6.6%
sub-neg6.6%
fma-udef6.6%
unpow26.6%
+-commutative6.6%
associate--l+59.7%
+-inverses100.0%
metadata-eval100.0%
metadata-eval100.0%
neg-sub0100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in x around -inf 99.4%
*-commutative99.4%
associate-*r/99.4%
metadata-eval99.4%
Simplified99.4%
if -0.94999999999999996 < x < 1.25Initial program 12.1%
sqr-neg12.1%
+-commutative12.1%
sqr-neg12.1%
hypot-1-def12.1%
Simplified12.1%
Taylor expanded in x around 0 98.6%
if 1.25 < x Initial program 52.3%
sqr-neg52.3%
+-commutative52.3%
sqr-neg52.3%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.4%
*-commutative99.4%
Simplified99.4%
Final simplification99.0%
(FPCore (x) :precision binary64 (if (<= x -1.25) (log (/ -0.5 x)) (if (<= x 1.25) x (log (* x 2.0)))))
double code(double x) {
double tmp;
if (x <= -1.25) {
tmp = log((-0.5 / x));
} else if (x <= 1.25) {
tmp = x;
} else {
tmp = log((x * 2.0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-1.25d0)) then
tmp = log(((-0.5d0) / x))
else if (x <= 1.25d0) then
tmp = x
else
tmp = log((x * 2.0d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -1.25) {
tmp = Math.log((-0.5 / x));
} else if (x <= 1.25) {
tmp = x;
} else {
tmp = Math.log((x * 2.0));
}
return tmp;
}
def code(x): tmp = 0 if x <= -1.25: tmp = math.log((-0.5 / x)) elif x <= 1.25: tmp = x else: tmp = math.log((x * 2.0)) return tmp
function code(x) tmp = 0.0 if (x <= -1.25) tmp = log(Float64(-0.5 / x)); elseif (x <= 1.25) tmp = x; else tmp = log(Float64(x * 2.0)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -1.25) tmp = log((-0.5 / x)); elseif (x <= 1.25) tmp = x; else tmp = log((x * 2.0)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -1.25], N[Log[N[(-0.5 / x), $MachinePrecision]], $MachinePrecision], If[LessEqual[x, 1.25], x, N[Log[N[(x * 2.0), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.25:\\
\;\;\;\;\log \left(\frac{-0.5}{x}\right)\\
\mathbf{elif}\;x \leq 1.25:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2\right)\\
\end{array}
\end{array}
if x < -1.25Initial program 5.7%
sqr-neg5.7%
+-commutative5.7%
sqr-neg5.7%
hypot-1-def6.7%
Simplified6.7%
Taylor expanded in x around -inf 98.1%
if -1.25 < x < 1.25Initial program 12.1%
sqr-neg12.1%
+-commutative12.1%
sqr-neg12.1%
hypot-1-def12.1%
Simplified12.1%
Taylor expanded in x around 0 97.1%
if 1.25 < x Initial program 52.3%
sqr-neg52.3%
+-commutative52.3%
sqr-neg52.3%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.4%
*-commutative99.4%
Simplified99.4%
Final simplification97.9%
(FPCore (x) :precision binary64 (if (<= x -1.25) (- (log (* x -2.0))) (if (<= x 1.25) x (log (* x 2.0)))))
double code(double x) {
double tmp;
if (x <= -1.25) {
tmp = -log((x * -2.0));
} else if (x <= 1.25) {
tmp = x;
} else {
tmp = log((x * 2.0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-1.25d0)) then
tmp = -log((x * (-2.0d0)))
else if (x <= 1.25d0) then
tmp = x
else
tmp = log((x * 2.0d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -1.25) {
tmp = -Math.log((x * -2.0));
} else if (x <= 1.25) {
tmp = x;
} else {
tmp = Math.log((x * 2.0));
}
return tmp;
}
def code(x): tmp = 0 if x <= -1.25: tmp = -math.log((x * -2.0)) elif x <= 1.25: tmp = x else: tmp = math.log((x * 2.0)) return tmp
function code(x) tmp = 0.0 if (x <= -1.25) tmp = Float64(-log(Float64(x * -2.0))); elseif (x <= 1.25) tmp = x; else tmp = log(Float64(x * 2.0)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -1.25) tmp = -log((x * -2.0)); elseif (x <= 1.25) tmp = x; else tmp = log((x * 2.0)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -1.25], (-N[Log[N[(x * -2.0), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 1.25], x, N[Log[N[(x * 2.0), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.25:\\
\;\;\;\;-\log \left(x \cdot -2\right)\\
\mathbf{elif}\;x \leq 1.25:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2\right)\\
\end{array}
\end{array}
if x < -1.25Initial program 5.7%
sqr-neg5.7%
+-commutative5.7%
sqr-neg5.7%
hypot-1-def6.7%
Simplified6.7%
flip-+6.6%
frac-2neg6.6%
log-div6.6%
pow26.6%
hypot-1-def6.6%
hypot-1-def6.6%
add-sqr-sqrt6.6%
+-commutative6.6%
fma-def6.6%
Applied egg-rr6.6%
neg-sub06.6%
associate--r-6.6%
neg-sub06.6%
+-commutative6.6%
sub-neg6.6%
fma-udef6.6%
unpow26.6%
+-commutative6.6%
associate--l+59.7%
+-inverses100.0%
metadata-eval100.0%
metadata-eval100.0%
neg-sub0100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in x around -inf 98.1%
*-commutative98.1%
Simplified98.1%
if -1.25 < x < 1.25Initial program 12.1%
sqr-neg12.1%
+-commutative12.1%
sqr-neg12.1%
hypot-1-def12.1%
Simplified12.1%
Taylor expanded in x around 0 97.1%
if 1.25 < x Initial program 52.3%
sqr-neg52.3%
+-commutative52.3%
sqr-neg52.3%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.4%
*-commutative99.4%
Simplified99.4%
Final simplification97.9%
(FPCore (x) :precision binary64 (if (<= x 1.25) x (log (* x 2.0))))
double code(double x) {
double tmp;
if (x <= 1.25) {
tmp = x;
} else {
tmp = log((x * 2.0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 1.25d0) then
tmp = x
else
tmp = log((x * 2.0d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 1.25) {
tmp = x;
} else {
tmp = Math.log((x * 2.0));
}
return tmp;
}
def code(x): tmp = 0 if x <= 1.25: tmp = x else: tmp = math.log((x * 2.0)) return tmp
function code(x) tmp = 0.0 if (x <= 1.25) tmp = x; else tmp = log(Float64(x * 2.0)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 1.25) tmp = x; else tmp = log((x * 2.0)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 1.25], x, N[Log[N[(x * 2.0), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 1.25:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2\right)\\
\end{array}
\end{array}
if x < 1.25Initial program 10.0%
sqr-neg10.0%
+-commutative10.0%
sqr-neg10.0%
hypot-1-def10.4%
Simplified10.4%
Taylor expanded in x around 0 67.5%
if 1.25 < x Initial program 52.3%
sqr-neg52.3%
+-commutative52.3%
sqr-neg52.3%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.4%
*-commutative99.4%
Simplified99.4%
Final simplification75.6%
(FPCore (x) :precision binary64 x)
double code(double x) {
return x;
}
real(8) function code(x)
real(8), intent (in) :: x
code = x
end function
public static double code(double x) {
return x;
}
def code(x): return x
function code(x) return x end
function tmp = code(x) tmp = x; end
code[x_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 20.8%
sqr-neg20.8%
+-commutative20.8%
sqr-neg20.8%
hypot-1-def33.1%
Simplified33.1%
Taylor expanded in x around 0 51.8%
Final simplification51.8%
(FPCore (x) :precision binary64 (let* ((t_0 (sqrt (+ (* x x) 1.0)))) (if (< x 0.0) (log (/ -1.0 (- x t_0))) (log (+ x t_0)))))
double code(double x) {
double t_0 = sqrt(((x * x) + 1.0));
double tmp;
if (x < 0.0) {
tmp = log((-1.0 / (x - t_0)));
} else {
tmp = log((x + t_0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = sqrt(((x * x) + 1.0d0))
if (x < 0.0d0) then
tmp = log(((-1.0d0) / (x - t_0)))
else
tmp = log((x + t_0))
end if
code = tmp
end function
public static double code(double x) {
double t_0 = Math.sqrt(((x * x) + 1.0));
double tmp;
if (x < 0.0) {
tmp = Math.log((-1.0 / (x - t_0)));
} else {
tmp = Math.log((x + t_0));
}
return tmp;
}
def code(x): t_0 = math.sqrt(((x * x) + 1.0)) tmp = 0 if x < 0.0: tmp = math.log((-1.0 / (x - t_0))) else: tmp = math.log((x + t_0)) return tmp
function code(x) t_0 = sqrt(Float64(Float64(x * x) + 1.0)) tmp = 0.0 if (x < 0.0) tmp = log(Float64(-1.0 / Float64(x - t_0))); else tmp = log(Float64(x + t_0)); end return tmp end
function tmp_2 = code(x) t_0 = sqrt(((x * x) + 1.0)); tmp = 0.0; if (x < 0.0) tmp = log((-1.0 / (x - t_0))); else tmp = log((x + t_0)); end tmp_2 = tmp; end
code[x_] := Block[{t$95$0 = N[Sqrt[N[(N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]}, If[Less[x, 0.0], N[Log[N[(-1.0 / N[(x - t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Log[N[(x + t$95$0), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{x \cdot x + 1}\\
\mathbf{if}\;x < 0:\\
\;\;\;\;\log \left(\frac{-1}{x - t_0}\right)\\
\mathbf{else}:\\
\;\;\;\;\log \left(x + t_0\right)\\
\end{array}
\end{array}
herbie shell --seed 2023334
(FPCore (x)
:name "Hyperbolic arcsine"
:precision binary64
:herbie-target
(if (< x 0.0) (log (/ -1.0 (- x (sqrt (+ (* x x) 1.0))))) (log (+ x (sqrt (+ (* x x) 1.0)))))
(log (+ x (sqrt (+ (* x x) 1.0)))))