
(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 12 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 -29.0)
(log
(+
(/ 0.125 (pow x 3.0))
(- (/ 0.0390625 (pow x 7.0)) (+ (/ 0.5 x) (/ 0.0625 (pow x 5.0))))))
(log1p (+ x (* x (/ x (+ 1.0 (hypot 1.0 x))))))))
double code(double x) {
double tmp;
if (x <= -29.0) {
tmp = log(((0.125 / pow(x, 3.0)) + ((0.0390625 / pow(x, 7.0)) - ((0.5 / x) + (0.0625 / pow(x, 5.0))))));
} else {
tmp = log1p((x + (x * (x / (1.0 + hypot(1.0, x))))));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -29.0) {
tmp = Math.log(((0.125 / Math.pow(x, 3.0)) + ((0.0390625 / Math.pow(x, 7.0)) - ((0.5 / x) + (0.0625 / Math.pow(x, 5.0))))));
} else {
tmp = Math.log1p((x + (x * (x / (1.0 + Math.hypot(1.0, x))))));
}
return tmp;
}
def code(x): tmp = 0 if x <= -29.0: tmp = math.log(((0.125 / math.pow(x, 3.0)) + ((0.0390625 / math.pow(x, 7.0)) - ((0.5 / x) + (0.0625 / math.pow(x, 5.0)))))) else: tmp = math.log1p((x + (x * (x / (1.0 + math.hypot(1.0, x)))))) return tmp
function code(x) tmp = 0.0 if (x <= -29.0) tmp = log(Float64(Float64(0.125 / (x ^ 3.0)) + Float64(Float64(0.0390625 / (x ^ 7.0)) - Float64(Float64(0.5 / x) + Float64(0.0625 / (x ^ 5.0)))))); else tmp = log1p(Float64(x + Float64(x * Float64(x / Float64(1.0 + hypot(1.0, x)))))); end return tmp end
code[x_] := If[LessEqual[x, -29.0], N[Log[N[(N[(0.125 / N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(0.0390625 / N[Power[x, 7.0], $MachinePrecision]), $MachinePrecision] - N[(N[(0.5 / x), $MachinePrecision] + N[(0.0625 / N[Power[x, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Log[1 + N[(x + N[(x * N[(x / N[(1.0 + N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -29:\\
\;\;\;\;\log \left(\frac{0.125}{{x}^{3}} + \left(\frac{0.0390625}{{x}^{7}} - \left(\frac{0.5}{x} + \frac{0.0625}{{x}^{5}}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(x + x \cdot \frac{x}{1 + \mathsf{hypot}\left(1, x\right)}\right)\\
\end{array}
\end{array}
if x < -29Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
Taylor expanded in x around -inf 100.0%
+-commutative100.0%
associate--l+100.0%
associate-*r/100.0%
metadata-eval100.0%
associate-*r/100.0%
metadata-eval100.0%
+-commutative100.0%
associate-*r/100.0%
metadata-eval100.0%
associate-*r/100.0%
metadata-eval100.0%
Simplified100.0%
if -29 < x Initial program 23.0%
sqr-neg23.0%
+-commutative23.0%
sqr-neg23.0%
hypot-1-def42.1%
Simplified42.1%
add-cube-cbrt41.9%
pow341.9%
log-pow41.7%
Applied egg-rr41.7%
log1p-expm1-u41.7%
log1p-udef41.7%
expm1-udef41.7%
*-commutative41.7%
exp-to-pow41.9%
pow341.9%
add-cube-cbrt42.1%
Applied egg-rr42.1%
log1p-def42.1%
associate--l+99.1%
Simplified99.1%
sub-neg99.1%
metadata-eval99.1%
flip-+80.1%
hypot-1-def80.1%
hypot-1-def80.1%
add-sqr-sqrt80.1%
add-exp-log80.1%
log1p-udef80.1%
metadata-eval80.1%
expm1-udef80.9%
expm1-log1p-u80.9%
pow280.9%
Applied egg-rr80.9%
unpow280.9%
*-un-lft-identity80.9%
times-frac100.0%
sub-neg100.0%
metadata-eval100.0%
+-commutative100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x) :precision binary64 (if (<= x -100.0) (- (log (- (hypot 1.0 x) x))) (log1p (+ x (* x (/ x (+ 1.0 (hypot 1.0 x))))))))
double code(double x) {
double tmp;
if (x <= -100.0) {
tmp = -log((hypot(1.0, x) - x));
} else {
tmp = log1p((x + (x * (x / (1.0 + hypot(1.0, x))))));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -100.0) {
tmp = -Math.log((Math.hypot(1.0, x) - x));
} else {
tmp = Math.log1p((x + (x * (x / (1.0 + Math.hypot(1.0, x))))));
}
return tmp;
}
def code(x): tmp = 0 if x <= -100.0: tmp = -math.log((math.hypot(1.0, x) - x)) else: tmp = math.log1p((x + (x * (x / (1.0 + math.hypot(1.0, x)))))) return tmp
function code(x) tmp = 0.0 if (x <= -100.0) tmp = Float64(-log(Float64(hypot(1.0, x) - x))); else tmp = log1p(Float64(x + Float64(x * Float64(x / Float64(1.0 + hypot(1.0, x)))))); end return tmp end
code[x_] := If[LessEqual[x, -100.0], (-N[Log[N[(N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision] - x), $MachinePrecision]], $MachinePrecision]), N[Log[1 + N[(x + N[(x * N[(x / N[(1.0 + N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -100:\\
\;\;\;\;-\log \left(\mathsf{hypot}\left(1, x\right) - x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(x + x \cdot \frac{x}{1 + \mathsf{hypot}\left(1, x\right)}\right)\\
\end{array}
\end{array}
if x < -100Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
flip-+4.0%
frac-2neg4.0%
log-div4.0%
pow24.0%
hypot-1-def4.0%
hypot-1-def4.0%
add-sqr-sqrt4.5%
+-commutative4.5%
fma-def4.5%
Applied egg-rr4.5%
neg-sub04.5%
associate--r-4.5%
neg-sub04.5%
+-commutative4.5%
sub-neg4.5%
fma-udef4.5%
unpow24.5%
+-commutative4.5%
associate--l+47.6%
+-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 -100 < x Initial program 23.0%
sqr-neg23.0%
+-commutative23.0%
sqr-neg23.0%
hypot-1-def42.1%
Simplified42.1%
add-cube-cbrt41.9%
pow341.9%
log-pow41.7%
Applied egg-rr41.7%
log1p-expm1-u41.7%
log1p-udef41.7%
expm1-udef41.7%
*-commutative41.7%
exp-to-pow41.9%
pow341.9%
add-cube-cbrt42.1%
Applied egg-rr42.1%
log1p-def42.1%
associate--l+99.1%
Simplified99.1%
sub-neg99.1%
metadata-eval99.1%
flip-+80.1%
hypot-1-def80.1%
hypot-1-def80.1%
add-sqr-sqrt80.1%
add-exp-log80.1%
log1p-udef80.1%
metadata-eval80.1%
expm1-udef80.9%
expm1-log1p-u80.9%
pow280.9%
Applied egg-rr80.9%
unpow280.9%
*-un-lft-identity80.9%
times-frac100.0%
sub-neg100.0%
metadata-eval100.0%
+-commutative100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x)
:precision binary64
(if (<= x -0.96)
(- (log (- (* x -2.0) (/ 0.5 x))))
(if (<= x 0.00092)
(+ x (* (pow x 3.0) -0.16666666666666666))
(log (+ x (hypot 1.0 x))))))
double code(double x) {
double tmp;
if (x <= -0.96) {
tmp = -log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.00092) {
tmp = x + (pow(x, 3.0) * -0.16666666666666666);
} else {
tmp = log((x + hypot(1.0, x)));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -0.96) {
tmp = -Math.log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.00092) {
tmp = x + (Math.pow(x, 3.0) * -0.16666666666666666);
} else {
tmp = Math.log((x + Math.hypot(1.0, x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.96: tmp = -math.log(((x * -2.0) - (0.5 / x))) elif x <= 0.00092: tmp = x + (math.pow(x, 3.0) * -0.16666666666666666) else: tmp = math.log((x + math.hypot(1.0, x))) return tmp
function code(x) tmp = 0.0 if (x <= -0.96) tmp = Float64(-log(Float64(Float64(x * -2.0) - Float64(0.5 / x)))); elseif (x <= 0.00092) tmp = Float64(x + Float64((x ^ 3.0) * -0.16666666666666666)); else tmp = log(Float64(x + hypot(1.0, x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.96) tmp = -log(((x * -2.0) - (0.5 / x))); elseif (x <= 0.00092) tmp = x + ((x ^ 3.0) * -0.16666666666666666); else tmp = log((x + hypot(1.0, x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.96], (-N[Log[N[(N[(x * -2.0), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.00092], N[(x + N[(N[Power[x, 3.0], $MachinePrecision] * -0.16666666666666666), $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.96:\\
\;\;\;\;-\log \left(x \cdot -2 - \frac{0.5}{x}\right)\\
\mathbf{elif}\;x \leq 0.00092:\\
\;\;\;\;x + {x}^{3} \cdot -0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;\log \left(x + \mathsf{hypot}\left(1, x\right)\right)\\
\end{array}
\end{array}
if x < -0.95999999999999996Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
flip-+4.0%
frac-2neg4.0%
log-div4.0%
pow24.0%
hypot-1-def4.0%
hypot-1-def4.0%
add-sqr-sqrt4.5%
+-commutative4.5%
fma-def4.5%
Applied egg-rr4.5%
neg-sub04.5%
associate--r-4.5%
neg-sub04.5%
+-commutative4.5%
sub-neg4.5%
fma-udef4.5%
unpow24.5%
+-commutative4.5%
associate--l+47.6%
+-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.2%
*-commutative99.2%
associate-*r/99.2%
metadata-eval99.2%
Simplified99.2%
if -0.95999999999999996 < x < 9.2000000000000003e-4Initial program 8.5%
sqr-neg8.5%
+-commutative8.5%
sqr-neg8.5%
hypot-1-def8.5%
Simplified8.5%
Taylor expanded in x around 0 99.8%
if 9.2000000000000003e-4 < x Initial program 48.0%
sqr-neg48.0%
+-commutative48.0%
sqr-neg48.0%
hypot-1-def99.8%
Simplified99.8%
Final simplification99.7%
(FPCore (x)
:precision binary64
(if (<= x -0.00105)
(- (log (- (hypot 1.0 x) x)))
(if (<= x 0.00092)
(+ x (* (pow x 3.0) -0.16666666666666666))
(log (+ x (hypot 1.0 x))))))
double code(double x) {
double tmp;
if (x <= -0.00105) {
tmp = -log((hypot(1.0, x) - x));
} else if (x <= 0.00092) {
tmp = x + (pow(x, 3.0) * -0.16666666666666666);
} else {
tmp = log((x + hypot(1.0, x)));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -0.00105) {
tmp = -Math.log((Math.hypot(1.0, x) - x));
} else if (x <= 0.00092) {
tmp = x + (Math.pow(x, 3.0) * -0.16666666666666666);
} else {
tmp = Math.log((x + Math.hypot(1.0, x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.00105: tmp = -math.log((math.hypot(1.0, x) - x)) elif x <= 0.00092: tmp = x + (math.pow(x, 3.0) * -0.16666666666666666) else: tmp = math.log((x + math.hypot(1.0, x))) return tmp
function code(x) tmp = 0.0 if (x <= -0.00105) tmp = Float64(-log(Float64(hypot(1.0, x) - x))); elseif (x <= 0.00092) tmp = Float64(x + Float64((x ^ 3.0) * -0.16666666666666666)); else tmp = log(Float64(x + hypot(1.0, x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.00105) tmp = -log((hypot(1.0, x) - x)); elseif (x <= 0.00092) tmp = x + ((x ^ 3.0) * -0.16666666666666666); else tmp = log((x + hypot(1.0, x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.00105], (-N[Log[N[(N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision] - x), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.00092], N[(x + N[(N[Power[x, 3.0], $MachinePrecision] * -0.16666666666666666), $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.00105:\\
\;\;\;\;-\log \left(\mathsf{hypot}\left(1, x\right) - x\right)\\
\mathbf{elif}\;x \leq 0.00092:\\
\;\;\;\;x + {x}^{3} \cdot -0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;\log \left(x + \mathsf{hypot}\left(1, x\right)\right)\\
\end{array}
\end{array}
if x < -0.00104999999999999994Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
flip-+4.0%
frac-2neg4.0%
log-div4.0%
pow24.0%
hypot-1-def4.0%
hypot-1-def4.0%
add-sqr-sqrt4.5%
+-commutative4.5%
fma-def4.5%
Applied egg-rr4.5%
neg-sub04.5%
associate--r-4.5%
neg-sub04.5%
+-commutative4.5%
sub-neg4.5%
fma-udef4.5%
unpow24.5%
+-commutative4.5%
associate--l+47.6%
+-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.00104999999999999994 < x < 9.2000000000000003e-4Initial program 8.5%
sqr-neg8.5%
+-commutative8.5%
sqr-neg8.5%
hypot-1-def8.5%
Simplified8.5%
Taylor expanded in x around 0 99.8%
if 9.2000000000000003e-4 < x Initial program 48.0%
sqr-neg48.0%
+-commutative48.0%
sqr-neg48.0%
hypot-1-def99.8%
Simplified99.8%
Final simplification99.9%
(FPCore (x) :precision binary64 (if (<= x -0.2) (- (log (- (hypot 1.0 x) x))) (log1p (+ x (+ (hypot 1.0 x) -1.0)))))
double code(double x) {
double tmp;
if (x <= -0.2) {
tmp = -log((hypot(1.0, x) - x));
} else {
tmp = log1p((x + (hypot(1.0, x) + -1.0)));
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= -0.2) {
tmp = -Math.log((Math.hypot(1.0, x) - x));
} else {
tmp = Math.log1p((x + (Math.hypot(1.0, x) + -1.0)));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.2: tmp = -math.log((math.hypot(1.0, x) - x)) else: tmp = math.log1p((x + (math.hypot(1.0, x) + -1.0))) return tmp
function code(x) tmp = 0.0 if (x <= -0.2) tmp = Float64(-log(Float64(hypot(1.0, x) - x))); else tmp = log1p(Float64(x + Float64(hypot(1.0, x) + -1.0))); end return tmp end
code[x_] := If[LessEqual[x, -0.2], (-N[Log[N[(N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision] - x), $MachinePrecision]], $MachinePrecision]), N[Log[1 + N[(x + N[(N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.2:\\
\;\;\;\;-\log \left(\mathsf{hypot}\left(1, x\right) - x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(x + \left(\mathsf{hypot}\left(1, x\right) + -1\right)\right)\\
\end{array}
\end{array}
if x < -0.20000000000000001Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
flip-+4.0%
frac-2neg4.0%
log-div4.0%
pow24.0%
hypot-1-def4.0%
hypot-1-def4.0%
add-sqr-sqrt4.5%
+-commutative4.5%
fma-def4.5%
Applied egg-rr4.5%
neg-sub04.5%
associate--r-4.5%
neg-sub04.5%
+-commutative4.5%
sub-neg4.5%
fma-udef4.5%
unpow24.5%
+-commutative4.5%
associate--l+47.6%
+-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.20000000000000001 < x Initial program 23.0%
sqr-neg23.0%
+-commutative23.0%
sqr-neg23.0%
hypot-1-def42.1%
Simplified42.1%
add-cube-cbrt41.9%
pow341.9%
log-pow41.7%
Applied egg-rr41.7%
log1p-expm1-u41.7%
log1p-udef41.7%
expm1-udef41.7%
*-commutative41.7%
exp-to-pow41.9%
pow341.9%
add-cube-cbrt42.1%
Applied egg-rr42.1%
log1p-def42.1%
associate--l+99.1%
Simplified99.1%
Final simplification99.3%
(FPCore (x)
:precision binary64
(if (<= x -0.96)
(- (log (- (* x -2.0) (/ 0.5 x))))
(if (<= x 0.96)
(+ x (* (pow x 3.0) -0.16666666666666666))
(log (+ (* x 2.0) (* 0.5 (/ 1.0 x)))))))
double code(double x) {
double tmp;
if (x <= -0.96) {
tmp = -log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.96) {
tmp = x + (pow(x, 3.0) * -0.16666666666666666);
} 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.96d0)) then
tmp = -log(((x * (-2.0d0)) - (0.5d0 / x)))
else if (x <= 0.96d0) then
tmp = x + ((x ** 3.0d0) * (-0.16666666666666666d0))
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.96) {
tmp = -Math.log(((x * -2.0) - (0.5 / x)));
} else if (x <= 0.96) {
tmp = x + (Math.pow(x, 3.0) * -0.16666666666666666);
} else {
tmp = Math.log(((x * 2.0) + (0.5 * (1.0 / x))));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.96: tmp = -math.log(((x * -2.0) - (0.5 / x))) elif x <= 0.96: tmp = x + (math.pow(x, 3.0) * -0.16666666666666666) else: tmp = math.log(((x * 2.0) + (0.5 * (1.0 / x)))) return tmp
function code(x) tmp = 0.0 if (x <= -0.96) tmp = Float64(-log(Float64(Float64(x * -2.0) - Float64(0.5 / x)))); elseif (x <= 0.96) tmp = Float64(x + Float64((x ^ 3.0) * -0.16666666666666666)); 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.96) tmp = -log(((x * -2.0) - (0.5 / x))); elseif (x <= 0.96) tmp = x + ((x ^ 3.0) * -0.16666666666666666); else tmp = log(((x * 2.0) + (0.5 * (1.0 / x)))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.96], (-N[Log[N[(N[(x * -2.0), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 0.96], N[(x + N[(N[Power[x, 3.0], $MachinePrecision] * -0.16666666666666666), $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.96:\\
\;\;\;\;-\log \left(x \cdot -2 - \frac{0.5}{x}\right)\\
\mathbf{elif}\;x \leq 0.96:\\
\;\;\;\;x + {x}^{3} \cdot -0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2 + 0.5 \cdot \frac{1}{x}\right)\\
\end{array}
\end{array}
if x < -0.95999999999999996Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
flip-+4.0%
frac-2neg4.0%
log-div4.0%
pow24.0%
hypot-1-def4.0%
hypot-1-def4.0%
add-sqr-sqrt4.5%
+-commutative4.5%
fma-def4.5%
Applied egg-rr4.5%
neg-sub04.5%
associate--r-4.5%
neg-sub04.5%
+-commutative4.5%
sub-neg4.5%
fma-udef4.5%
unpow24.5%
+-commutative4.5%
associate--l+47.6%
+-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.2%
*-commutative99.2%
associate-*r/99.2%
metadata-eval99.2%
Simplified99.2%
if -0.95999999999999996 < x < 0.95999999999999996Initial program 9.8%
sqr-neg9.8%
+-commutative9.8%
sqr-neg9.8%
hypot-1-def9.8%
Simplified9.8%
Taylor expanded in x around 0 99.2%
if 0.95999999999999996 < x Initial program 46.7%
sqr-neg46.7%
+-commutative46.7%
sqr-neg46.7%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification99.4%
(FPCore (x)
:precision binary64
(if (<= x -1.25)
(log (/ -0.5 x))
(if (<= x 1.25)
(+ x (* (pow x 3.0) -0.16666666666666666))
(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 + (pow(x, 3.0) * -0.16666666666666666);
} 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 + ((x ** 3.0d0) * (-0.16666666666666666d0))
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 + (Math.pow(x, 3.0) * -0.16666666666666666);
} 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 + (math.pow(x, 3.0) * -0.16666666666666666) 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 = Float64(x + Float64((x ^ 3.0) * -0.16666666666666666)); 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 + ((x ^ 3.0) * -0.16666666666666666); 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], N[(x + N[(N[Power[x, 3.0], $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], 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 + {x}^{3} \cdot -0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2\right)\\
\end{array}
\end{array}
if x < -1.25Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
Taylor expanded in x around -inf 98.4%
if -1.25 < x < 1.25Initial program 9.8%
sqr-neg9.8%
+-commutative9.8%
sqr-neg9.8%
hypot-1-def9.8%
Simplified9.8%
Taylor expanded in x around 0 99.2%
if 1.25 < x Initial program 46.7%
sqr-neg46.7%
+-commutative46.7%
sqr-neg46.7%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.0%
*-commutative99.0%
Simplified99.0%
Final simplification98.9%
(FPCore (x)
:precision binary64
(if (<= x -0.96)
(- (log (- (* x -2.0) (/ 0.5 x))))
(if (<= x 1.25)
(+ x (* (pow x 3.0) -0.16666666666666666))
(log (* x 2.0)))))
double code(double x) {
double tmp;
if (x <= -0.96) {
tmp = -log(((x * -2.0) - (0.5 / x)));
} else if (x <= 1.25) {
tmp = x + (pow(x, 3.0) * -0.16666666666666666);
} else {
tmp = log((x * 2.0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-0.96d0)) then
tmp = -log(((x * (-2.0d0)) - (0.5d0 / x)))
else if (x <= 1.25d0) then
tmp = x + ((x ** 3.0d0) * (-0.16666666666666666d0))
else
tmp = log((x * 2.0d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -0.96) {
tmp = -Math.log(((x * -2.0) - (0.5 / x)));
} else if (x <= 1.25) {
tmp = x + (Math.pow(x, 3.0) * -0.16666666666666666);
} else {
tmp = Math.log((x * 2.0));
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.96: tmp = -math.log(((x * -2.0) - (0.5 / x))) elif x <= 1.25: tmp = x + (math.pow(x, 3.0) * -0.16666666666666666) else: tmp = math.log((x * 2.0)) return tmp
function code(x) tmp = 0.0 if (x <= -0.96) tmp = Float64(-log(Float64(Float64(x * -2.0) - Float64(0.5 / x)))); elseif (x <= 1.25) tmp = Float64(x + Float64((x ^ 3.0) * -0.16666666666666666)); else tmp = log(Float64(x * 2.0)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.96) tmp = -log(((x * -2.0) - (0.5 / x))); elseif (x <= 1.25) tmp = x + ((x ^ 3.0) * -0.16666666666666666); else tmp = log((x * 2.0)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.96], (-N[Log[N[(N[(x * -2.0), $MachinePrecision] - N[(0.5 / x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), If[LessEqual[x, 1.25], N[(x + N[(N[Power[x, 3.0], $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision], N[Log[N[(x * 2.0), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.96:\\
\;\;\;\;-\log \left(x \cdot -2 - \frac{0.5}{x}\right)\\
\mathbf{elif}\;x \leq 1.25:\\
\;\;\;\;x + {x}^{3} \cdot -0.16666666666666666\\
\mathbf{else}:\\
\;\;\;\;\log \left(x \cdot 2\right)\\
\end{array}
\end{array}
if x < -0.95999999999999996Initial program 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
flip-+4.0%
frac-2neg4.0%
log-div4.0%
pow24.0%
hypot-1-def4.0%
hypot-1-def4.0%
add-sqr-sqrt4.5%
+-commutative4.5%
fma-def4.5%
Applied egg-rr4.5%
neg-sub04.5%
associate--r-4.5%
neg-sub04.5%
+-commutative4.5%
sub-neg4.5%
fma-udef4.5%
unpow24.5%
+-commutative4.5%
associate--l+47.6%
+-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.2%
*-commutative99.2%
associate-*r/99.2%
metadata-eval99.2%
Simplified99.2%
if -0.95999999999999996 < x < 1.25Initial program 9.8%
sqr-neg9.8%
+-commutative9.8%
sqr-neg9.8%
hypot-1-def9.8%
Simplified9.8%
Taylor expanded in x around 0 99.2%
if 1.25 < x Initial program 46.7%
sqr-neg46.7%
+-commutative46.7%
sqr-neg46.7%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.0%
*-commutative99.0%
Simplified99.0%
Final simplification99.2%
(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 4.3%
sqr-neg4.3%
+-commutative4.3%
sqr-neg4.3%
hypot-1-def5.7%
Simplified5.7%
Taylor expanded in x around -inf 98.4%
if -1.25 < x < 1.25Initial program 9.8%
sqr-neg9.8%
+-commutative9.8%
sqr-neg9.8%
hypot-1-def9.8%
Simplified9.8%
Taylor expanded in x around 0 98.2%
if 1.25 < x Initial program 46.7%
sqr-neg46.7%
+-commutative46.7%
sqr-neg46.7%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.0%
*-commutative99.0%
Simplified99.0%
Final simplification98.5%
(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 8.0%
sqr-neg8.0%
+-commutative8.0%
sqr-neg8.0%
hypot-1-def8.4%
Simplified8.4%
Taylor expanded in x around 0 66.9%
if 1.25 < x Initial program 46.7%
sqr-neg46.7%
+-commutative46.7%
sqr-neg46.7%
hypot-1-def100.0%
Simplified100.0%
Taylor expanded in x around inf 99.0%
*-commutative99.0%
Simplified99.0%
Final simplification75.6%
(FPCore (x) :precision binary64 (if (<= x 1.56) x (log1p x)))
double code(double x) {
double tmp;
if (x <= 1.56) {
tmp = x;
} else {
tmp = log1p(x);
}
return tmp;
}
public static double code(double x) {
double tmp;
if (x <= 1.56) {
tmp = x;
} else {
tmp = Math.log1p(x);
}
return tmp;
}
def code(x): tmp = 0 if x <= 1.56: tmp = x else: tmp = math.log1p(x) return tmp
function code(x) tmp = 0.0 if (x <= 1.56) tmp = x; else tmp = log1p(x); end return tmp end
code[x_] := If[LessEqual[x, 1.56], x, N[Log[1 + x], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 1.56:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\mathsf{log1p}\left(x\right)\\
\end{array}
\end{array}
if x < 1.5600000000000001Initial program 8.0%
sqr-neg8.0%
+-commutative8.0%
sqr-neg8.0%
hypot-1-def8.4%
Simplified8.4%
Taylor expanded in x around 0 66.9%
if 1.5600000000000001 < x Initial program 46.7%
sqr-neg46.7%
+-commutative46.7%
sqr-neg46.7%
hypot-1-def100.0%
Simplified100.0%
add-cube-cbrt100.0%
pow3100.0%
log-pow99.6%
Applied egg-rr99.6%
log1p-expm1-u99.6%
log1p-udef99.6%
expm1-udef99.6%
*-commutative99.6%
exp-to-pow100.0%
pow3100.0%
add-cube-cbrt100.0%
Applied egg-rr100.0%
log1p-def100.0%
associate--l+100.0%
Simplified100.0%
Taylor expanded in x around 0 31.7%
Final simplification57.4%
(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 18.4%
sqr-neg18.4%
+-commutative18.4%
sqr-neg18.4%
hypot-1-def33.1%
Simplified33.1%
Taylor expanded in x around 0 50.3%
Final simplification50.3%
(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 2023338
(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)))))