
(FPCore (x) :precision binary64 (/ x (+ 1.0 (sqrt (+ x 1.0)))))
double code(double x) {
return x / (1.0 + sqrt((x + 1.0)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = x / (1.0d0 + sqrt((x + 1.0d0)))
end function
public static double code(double x) {
return x / (1.0 + Math.sqrt((x + 1.0)));
}
def code(x): return x / (1.0 + math.sqrt((x + 1.0)))
function code(x) return Float64(x / Float64(1.0 + sqrt(Float64(x + 1.0)))) end
function tmp = code(x) tmp = x / (1.0 + sqrt((x + 1.0))); end
code[x_] := N[(x / N[(1.0 + N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{1 + \sqrt{x + 1}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 6 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (/ x (+ 1.0 (sqrt (+ x 1.0)))))
double code(double x) {
return x / (1.0 + sqrt((x + 1.0)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = x / (1.0d0 + sqrt((x + 1.0d0)))
end function
public static double code(double x) {
return x / (1.0 + Math.sqrt((x + 1.0)));
}
def code(x): return x / (1.0 + math.sqrt((x + 1.0)))
function code(x) return Float64(x / Float64(1.0 + sqrt(Float64(x + 1.0)))) end
function tmp = code(x) tmp = x / (1.0 + sqrt((x + 1.0))); end
code[x_] := N[(x / N[(1.0 + N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{1 + \sqrt{x + 1}}
\end{array}
(FPCore (x) :precision binary64 (if (<= x 5.6e-6) (* x (- (- -0.5) (* x 0.125))) (+ (sqrt (+ x 1.0)) -1.0)))
double code(double x) {
double tmp;
if (x <= 5.6e-6) {
tmp = x * (-(-0.5) - (x * 0.125));
} else {
tmp = sqrt((x + 1.0)) + -1.0;
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 5.6d-6) then
tmp = x * (-(-0.5d0) - (x * 0.125d0))
else
tmp = sqrt((x + 1.0d0)) + (-1.0d0)
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 5.6e-6) {
tmp = x * (-(-0.5) - (x * 0.125));
} else {
tmp = Math.sqrt((x + 1.0)) + -1.0;
}
return tmp;
}
def code(x): tmp = 0 if x <= 5.6e-6: tmp = x * (-(-0.5) - (x * 0.125)) else: tmp = math.sqrt((x + 1.0)) + -1.0 return tmp
function code(x) tmp = 0.0 if (x <= 5.6e-6) tmp = Float64(x * Float64(Float64(-(-0.5)) - Float64(x * 0.125))); else tmp = Float64(sqrt(Float64(x + 1.0)) + -1.0); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 5.6e-6) tmp = x * (-(-0.5) - (x * 0.125)); else tmp = sqrt((x + 1.0)) + -1.0; end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 5.6e-6], N[(x * N[((--0.5) - N[(x * 0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 5.6 \cdot 10^{-6}:\\
\;\;\;\;x \cdot \left(\left(--0.5\right) - x \cdot 0.125\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{x + 1} + -1\\
\end{array}
\end{array}
if x < 5.59999999999999975e-6Initial program 100.0%
frac-2neg100.0%
distribute-frac-neg100.0%
neg-sub0100.0%
div-inv100.0%
cancel-sign-sub-inv100.0%
distribute-lft-neg-out100.0%
div-inv100.0%
remove-double-neg100.0%
neg-sub0100.0%
metadata-eval100.0%
associate--r+7.7%
metadata-eval7.7%
+-commutative7.7%
rem-square-sqrt7.6%
frac-2neg7.6%
flip--7.6%
Applied egg-rr7.6%
sub-neg7.6%
associate--r-7.6%
metadata-eval7.6%
+-commutative7.6%
Simplified7.6%
+-commutative7.6%
flip-+7.6%
clear-num7.6%
metadata-eval7.6%
associate--r+7.6%
+-commutative7.6%
pow1/27.6%
metadata-eval7.6%
pow-prod-up7.6%
fma-udef7.6%
neg-sub07.6%
metadata-eval7.6%
rem-square-sqrt7.7%
+-commutative7.7%
associate--r+99.7%
metadata-eval99.7%
neg-sub099.7%
frac-2neg99.7%
div-inv99.7%
Applied egg-rr99.6%
Taylor expanded in x around 0 99.7%
*-commutative99.7%
Simplified99.7%
frac-2neg99.7%
div-inv99.7%
distribute-neg-in99.7%
metadata-eval99.7%
distribute-rgt-neg-in99.7%
metadata-eval99.7%
frac-2neg99.7%
remove-double-neg99.7%
distribute-neg-frac99.7%
remove-double-div100.0%
Applied egg-rr100.0%
if 5.59999999999999975e-6 < x Initial program 99.2%
frac-2neg99.2%
distribute-frac-neg99.2%
neg-sub099.2%
div-inv99.2%
cancel-sign-sub-inv99.2%
distribute-lft-neg-out99.2%
div-inv99.2%
remove-double-neg99.2%
neg-sub099.2%
metadata-eval99.2%
associate--r+98.8%
metadata-eval98.8%
+-commutative98.8%
rem-square-sqrt99.5%
frac-2neg99.5%
flip--99.6%
Applied egg-rr99.6%
sub-neg99.6%
associate--r-99.6%
metadata-eval99.6%
+-commutative99.6%
Simplified99.6%
Final simplification99.8%
(FPCore (x) :precision binary64 (let* ((t_0 (pow (+ x 1.0) 0.25))) (/ x (fma t_0 t_0 1.0))))
double code(double x) {
double t_0 = pow((x + 1.0), 0.25);
return x / fma(t_0, t_0, 1.0);
}
function code(x) t_0 = Float64(x + 1.0) ^ 0.25 return Float64(x / fma(t_0, t_0, 1.0)) end
code[x_] := Block[{t$95$0 = N[Power[N[(x + 1.0), $MachinePrecision], 0.25], $MachinePrecision]}, N[(x / N[(t$95$0 * t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(x + 1\right)}^{0.25}\\
\frac{x}{\mathsf{fma}\left(t_0, t_0, 1\right)}
\end{array}
\end{array}
Initial program 99.7%
+-commutative99.7%
pow1/299.7%
rem-square-sqrt99.7%
sqr-pow99.6%
fma-def99.6%
rem-square-sqrt99.7%
metadata-eval99.7%
rem-square-sqrt99.7%
metadata-eval99.7%
Applied egg-rr99.7%
Final simplification99.7%
(FPCore (x) :precision binary64 (/ x (+ 1.0 (sqrt (+ x 1.0)))))
double code(double x) {
return x / (1.0 + sqrt((x + 1.0)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = x / (1.0d0 + sqrt((x + 1.0d0)))
end function
public static double code(double x) {
return x / (1.0 + Math.sqrt((x + 1.0)));
}
def code(x): return x / (1.0 + math.sqrt((x + 1.0)))
function code(x) return Float64(x / Float64(1.0 + sqrt(Float64(x + 1.0)))) end
function tmp = code(x) tmp = x / (1.0 + sqrt((x + 1.0))); end
code[x_] := N[(x / N[(1.0 + N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{1 + \sqrt{x + 1}}
\end{array}
Initial program 99.7%
Final simplification99.7%
(FPCore (x) :precision binary64 (/ x (+ (* x 0.5) 2.0)))
double code(double x) {
return x / ((x * 0.5) + 2.0);
}
real(8) function code(x)
real(8), intent (in) :: x
code = x / ((x * 0.5d0) + 2.0d0)
end function
public static double code(double x) {
return x / ((x * 0.5) + 2.0);
}
def code(x): return x / ((x * 0.5) + 2.0)
function code(x) return Float64(x / Float64(Float64(x * 0.5) + 2.0)) end
function tmp = code(x) tmp = x / ((x * 0.5) + 2.0); end
code[x_] := N[(x / N[(N[(x * 0.5), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{x \cdot 0.5 + 2}
\end{array}
Initial program 99.7%
Taylor expanded in x around 0 69.5%
+-commutative69.5%
Simplified69.5%
Final simplification69.5%
(FPCore (x) :precision binary64 (/ x 2.0))
double code(double x) {
return x / 2.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = x / 2.0d0
end function
public static double code(double x) {
return x / 2.0;
}
def code(x): return x / 2.0
function code(x) return Float64(x / 2.0) end
function tmp = code(x) tmp = x / 2.0; end
code[x_] := N[(x / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{2}
\end{array}
Initial program 99.7%
Taylor expanded in x around 0 68.6%
Final simplification68.6%
(FPCore (x) :precision binary64 2.0)
double code(double x) {
return 2.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = 2.0d0
end function
public static double code(double x) {
return 2.0;
}
def code(x): return 2.0
function code(x) return 2.0 end
function tmp = code(x) tmp = 2.0; end
code[x_] := 2.0
\begin{array}{l}
\\
2
\end{array}
Initial program 99.7%
Taylor expanded in x around 0 69.5%
+-commutative69.5%
Simplified69.5%
+-commutative69.5%
flip-+68.9%
associate-/r/68.9%
swap-sqr68.9%
metadata-eval68.9%
cancel-sign-sub-inv68.9%
metadata-eval68.9%
metadata-eval68.9%
sub-neg68.9%
*-commutative68.9%
distribute-rgt-neg-in68.9%
metadata-eval68.9%
Applied egg-rr68.9%
Taylor expanded in x around inf 4.9%
Final simplification4.9%
herbie shell --seed 2023297
(FPCore (x)
:name "Numeric.Log:$clog1p from log-domain-0.10.2.1, B"
:precision binary64
(/ x (+ 1.0 (sqrt (+ x 1.0)))))