
(FPCore (x) :precision binary64 (- (/ 1.0 (sqrt x)) (/ 1.0 (sqrt (+ x 1.0)))))
double code(double x) {
return (1.0 / sqrt(x)) - (1.0 / sqrt((x + 1.0)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = (1.0d0 / sqrt(x)) - (1.0d0 / sqrt((x + 1.0d0)))
end function
public static double code(double x) {
return (1.0 / Math.sqrt(x)) - (1.0 / Math.sqrt((x + 1.0)));
}
def code(x): return (1.0 / math.sqrt(x)) - (1.0 / math.sqrt((x + 1.0)))
function code(x) return Float64(Float64(1.0 / sqrt(x)) - Float64(1.0 / sqrt(Float64(x + 1.0)))) end
function tmp = code(x) tmp = (1.0 / sqrt(x)) - (1.0 / sqrt((x + 1.0))); end
code[x_] := N[(N[(1.0 / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] - N[(1.0 / N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{\sqrt{x}} - \frac{1}{\sqrt{x + 1}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (- (/ 1.0 (sqrt x)) (/ 1.0 (sqrt (+ x 1.0)))))
double code(double x) {
return (1.0 / sqrt(x)) - (1.0 / sqrt((x + 1.0)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = (1.0d0 / sqrt(x)) - (1.0d0 / sqrt((x + 1.0d0)))
end function
public static double code(double x) {
return (1.0 / Math.sqrt(x)) - (1.0 / Math.sqrt((x + 1.0)));
}
def code(x): return (1.0 / math.sqrt(x)) - (1.0 / math.sqrt((x + 1.0)))
function code(x) return Float64(Float64(1.0 / sqrt(x)) - Float64(1.0 / sqrt(Float64(x + 1.0)))) end
function tmp = code(x) tmp = (1.0 / sqrt(x)) - (1.0 / sqrt((x + 1.0))); end
code[x_] := N[(N[(1.0 / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] - N[(1.0 / N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{\sqrt{x}} - \frac{1}{\sqrt{x + 1}}
\end{array}
(FPCore (x) :precision binary64 (if (<= x 5e+129) (/ (pow x -0.5) (+ (+ 1.0 x) (sqrt (+ x (* x x))))) (* (pow x -0.5) (/ 0.5 x))))
double code(double x) {
double tmp;
if (x <= 5e+129) {
tmp = pow(x, -0.5) / ((1.0 + x) + sqrt((x + (x * x))));
} else {
tmp = pow(x, -0.5) * (0.5 / x);
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 5d+129) then
tmp = (x ** (-0.5d0)) / ((1.0d0 + x) + sqrt((x + (x * x))))
else
tmp = (x ** (-0.5d0)) * (0.5d0 / x)
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 5e+129) {
tmp = Math.pow(x, -0.5) / ((1.0 + x) + Math.sqrt((x + (x * x))));
} else {
tmp = Math.pow(x, -0.5) * (0.5 / x);
}
return tmp;
}
def code(x): tmp = 0 if x <= 5e+129: tmp = math.pow(x, -0.5) / ((1.0 + x) + math.sqrt((x + (x * x)))) else: tmp = math.pow(x, -0.5) * (0.5 / x) return tmp
function code(x) tmp = 0.0 if (x <= 5e+129) tmp = Float64((x ^ -0.5) / Float64(Float64(1.0 + x) + sqrt(Float64(x + Float64(x * x))))); else tmp = Float64((x ^ -0.5) * Float64(0.5 / x)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 5e+129) tmp = (x ^ -0.5) / ((1.0 + x) + sqrt((x + (x * x)))); else tmp = (x ^ -0.5) * (0.5 / x); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 5e+129], N[(N[Power[x, -0.5], $MachinePrecision] / N[(N[(1.0 + x), $MachinePrecision] + N[Sqrt[N[(x + N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[x, -0.5], $MachinePrecision] * N[(0.5 / x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 5 \cdot 10^{+129}:\\
\;\;\;\;\frac{{x}^{-0.5}}{\left(1 + x\right) + \sqrt{x + x \cdot x}}\\
\mathbf{else}:\\
\;\;\;\;{x}^{-0.5} \cdot \frac{0.5}{x}\\
\end{array}
\end{array}
if x < 5.0000000000000003e129Initial program 76.1%
frac-sub76.1%
*-un-lft-identity76.1%
+-commutative76.1%
*-rgt-identity76.1%
sqrt-unprod76.1%
+-commutative76.1%
Applied egg-rr76.1%
flip--76.4%
add-sqr-sqrt76.9%
+-commutative76.9%
add-sqr-sqrt77.2%
associate--l+77.2%
+-commutative77.2%
Applied egg-rr77.2%
div-inv77.2%
sqrt-prod77.2%
+-commutative77.2%
times-frac77.2%
Applied egg-rr77.2%
associate-/l/77.2%
associate-*r/77.2%
metadata-eval77.2%
times-frac77.2%
*-rgt-identity77.2%
*-rgt-identity77.2%
associate-+r-77.2%
+-commutative77.2%
associate--l+99.5%
distribute-lft-in99.5%
rem-square-sqrt99.6%
+-commutative99.6%
+-commutative99.6%
Simplified99.6%
expm1-log1p-u94.5%
expm1-udef70.5%
+-inverses70.5%
metadata-eval70.5%
pow1/270.5%
pow-flip70.5%
metadata-eval70.5%
*-commutative70.5%
sqrt-unprod70.5%
Applied egg-rr70.5%
expm1-def94.6%
expm1-log1p99.9%
+-commutative99.9%
distribute-rgt-in99.9%
*-lft-identity99.9%
Simplified99.9%
if 5.0000000000000003e129 < x Initial program 56.8%
frac-sub56.8%
*-un-lft-identity56.8%
+-commutative56.8%
*-rgt-identity56.8%
sqrt-unprod56.8%
+-commutative56.8%
Applied egg-rr56.8%
add-cube-cbrt56.8%
sqrt-prod56.8%
times-frac56.8%
pow256.8%
+-commutative56.8%
+-commutative56.8%
+-commutative56.8%
Applied egg-rr56.8%
associate-*l/56.8%
associate-*r/56.8%
unpow256.8%
rem-3cbrt-lft56.8%
div-sub56.8%
*-inverses56.8%
Simplified56.8%
Taylor expanded in x around inf 99.8%
div-inv99.8%
metadata-eval99.8%
add-sqr-sqrt99.5%
frac-times99.5%
metadata-eval99.5%
+-inverses99.5%
metadata-eval99.5%
+-inverses99.5%
*-un-lft-identity99.5%
times-frac99.4%
metadata-eval99.4%
un-div-inv99.3%
metadata-eval99.3%
+-inverses99.3%
pow399.3%
Applied egg-rr99.4%
unpow399.5%
pow-sqr99.8%
metadata-eval99.8%
unpow-199.8%
associate-*r*99.8%
associate-*r/99.8%
metadata-eval99.8%
Simplified99.8%
Final simplification99.9%
(FPCore (x) :precision binary64 (/ (/ (+ 1.0 (- x x)) (sqrt x)) (+ (+ 1.0 x) (* (sqrt x) (sqrt (+ 1.0 x))))))
double code(double x) {
return ((1.0 + (x - x)) / sqrt(x)) / ((1.0 + x) + (sqrt(x) * sqrt((1.0 + x))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = ((1.0d0 + (x - x)) / sqrt(x)) / ((1.0d0 + x) + (sqrt(x) * sqrt((1.0d0 + x))))
end function
public static double code(double x) {
return ((1.0 + (x - x)) / Math.sqrt(x)) / ((1.0 + x) + (Math.sqrt(x) * Math.sqrt((1.0 + x))));
}
def code(x): return ((1.0 + (x - x)) / math.sqrt(x)) / ((1.0 + x) + (math.sqrt(x) * math.sqrt((1.0 + x))))
function code(x) return Float64(Float64(Float64(1.0 + Float64(x - x)) / sqrt(x)) / Float64(Float64(1.0 + x) + Float64(sqrt(x) * sqrt(Float64(1.0 + x))))) end
function tmp = code(x) tmp = ((1.0 + (x - x)) / sqrt(x)) / ((1.0 + x) + (sqrt(x) * sqrt((1.0 + x)))); end
code[x_] := N[(N[(N[(1.0 + N[(x - x), $MachinePrecision]), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + x), $MachinePrecision] + N[(N[Sqrt[x], $MachinePrecision] * N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{1 + \left(x - x\right)}{\sqrt{x}}}{\left(1 + x\right) + \sqrt{x} \cdot \sqrt{1 + x}}
\end{array}
Initial program 70.6%
frac-sub70.6%
*-un-lft-identity70.6%
+-commutative70.6%
*-rgt-identity70.6%
sqrt-unprod70.6%
+-commutative70.6%
Applied egg-rr70.6%
flip--70.8%
add-sqr-sqrt71.2%
+-commutative71.2%
add-sqr-sqrt71.4%
associate--l+71.4%
+-commutative71.4%
Applied egg-rr71.4%
div-inv71.4%
sqrt-prod71.4%
+-commutative71.4%
times-frac71.4%
Applied egg-rr71.4%
associate-/l/71.4%
associate-*r/71.4%
metadata-eval71.4%
times-frac71.4%
*-rgt-identity71.4%
*-rgt-identity71.4%
associate-+r-71.4%
+-commutative71.4%
associate--l+99.5%
distribute-lft-in99.5%
rem-square-sqrt99.6%
+-commutative99.6%
+-commutative99.6%
Simplified99.6%
Final simplification99.6%
(FPCore (x) :precision binary64 (if (<= x 6000.0) (- (pow x -0.5) (pow (+ 1.0 x) -0.5)) (/ (/ (+ 1.0 (- x x)) (sqrt x)) (+ 1.5 (- (* x 2.0) (/ 0.125 x))))))
double code(double x) {
double tmp;
if (x <= 6000.0) {
tmp = pow(x, -0.5) - pow((1.0 + x), -0.5);
} else {
tmp = ((1.0 + (x - x)) / sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x)));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 6000.0d0) then
tmp = (x ** (-0.5d0)) - ((1.0d0 + x) ** (-0.5d0))
else
tmp = ((1.0d0 + (x - x)) / sqrt(x)) / (1.5d0 + ((x * 2.0d0) - (0.125d0 / x)))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 6000.0) {
tmp = Math.pow(x, -0.5) - Math.pow((1.0 + x), -0.5);
} else {
tmp = ((1.0 + (x - x)) / Math.sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= 6000.0: tmp = math.pow(x, -0.5) - math.pow((1.0 + x), -0.5) else: tmp = ((1.0 + (x - x)) / math.sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x))) return tmp
function code(x) tmp = 0.0 if (x <= 6000.0) tmp = Float64((x ^ -0.5) - (Float64(1.0 + x) ^ -0.5)); else tmp = Float64(Float64(Float64(1.0 + Float64(x - x)) / sqrt(x)) / Float64(1.5 + Float64(Float64(x * 2.0) - Float64(0.125 / x)))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 6000.0) tmp = (x ^ -0.5) - ((1.0 + x) ^ -0.5); else tmp = ((1.0 + (x - x)) / sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 6000.0], N[(N[Power[x, -0.5], $MachinePrecision] - N[Power[N[(1.0 + x), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + N[(x - x), $MachinePrecision]), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] / N[(1.5 + N[(N[(x * 2.0), $MachinePrecision] - N[(0.125 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 6000:\\
\;\;\;\;{x}^{-0.5} - {\left(1 + x\right)}^{-0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \left(x - x\right)}{\sqrt{x}}}{1.5 + \left(x \cdot 2 - \frac{0.125}{x}\right)}\\
\end{array}
\end{array}
if x < 6e3Initial program 99.6%
*-un-lft-identity99.6%
clear-num99.6%
associate-/r/99.6%
prod-diff99.6%
*-un-lft-identity99.6%
fma-neg99.6%
*-un-lft-identity99.6%
inv-pow99.6%
sqrt-pow299.9%
metadata-eval99.9%
pow1/299.9%
pow-flip99.9%
+-commutative99.9%
metadata-eval99.9%
Applied egg-rr99.9%
fma-udef99.9%
distribute-lft1-in99.9%
metadata-eval99.9%
mul0-lft99.9%
+-rgt-identity99.9%
Simplified99.9%
if 6e3 < x Initial program 37.8%
frac-sub37.9%
*-un-lft-identity37.9%
+-commutative37.9%
*-rgt-identity37.9%
sqrt-unprod37.9%
+-commutative37.9%
Applied egg-rr37.9%
flip--38.2%
add-sqr-sqrt38.9%
+-commutative38.9%
add-sqr-sqrt39.4%
associate--l+39.4%
+-commutative39.4%
Applied egg-rr39.4%
div-inv39.4%
sqrt-prod39.4%
+-commutative39.4%
times-frac39.4%
Applied egg-rr39.4%
associate-/l/39.4%
associate-*r/39.4%
metadata-eval39.4%
times-frac39.4%
*-rgt-identity39.4%
*-rgt-identity39.4%
associate-+r-39.4%
+-commutative39.4%
associate--l+99.3%
distribute-lft-in99.3%
rem-square-sqrt99.5%
+-commutative99.5%
+-commutative99.5%
Simplified99.5%
Taylor expanded in x around inf 99.7%
associate--l+99.7%
*-commutative99.7%
associate-*r/99.7%
metadata-eval99.7%
Simplified99.7%
Final simplification99.8%
(FPCore (x)
:precision binary64
(if (<= x 0.43)
(+ (+ (pow x -0.5) (* x 0.5)) -1.0)
(/
(/ (+ 1.0 (- x x)) (sqrt x))
(+ (+ 1.0 x) (+ (/ 0.0625 (* x x)) (+ x (+ 0.5 (/ -0.125 x))))))))
double code(double x) {
double tmp;
if (x <= 0.43) {
tmp = (pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / sqrt(x)) / ((1.0 + x) + ((0.0625 / (x * x)) + (x + (0.5 + (-0.125 / x)))));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.43d0) then
tmp = ((x ** (-0.5d0)) + (x * 0.5d0)) + (-1.0d0)
else
tmp = ((1.0d0 + (x - x)) / sqrt(x)) / ((1.0d0 + x) + ((0.0625d0 / (x * x)) + (x + (0.5d0 + ((-0.125d0) / x)))))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.43) {
tmp = (Math.pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / Math.sqrt(x)) / ((1.0 + x) + ((0.0625 / (x * x)) + (x + (0.5 + (-0.125 / x)))));
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.43: tmp = (math.pow(x, -0.5) + (x * 0.5)) + -1.0 else: tmp = ((1.0 + (x - x)) / math.sqrt(x)) / ((1.0 + x) + ((0.0625 / (x * x)) + (x + (0.5 + (-0.125 / x))))) return tmp
function code(x) tmp = 0.0 if (x <= 0.43) tmp = Float64(Float64((x ^ -0.5) + Float64(x * 0.5)) + -1.0); else tmp = Float64(Float64(Float64(1.0 + Float64(x - x)) / sqrt(x)) / Float64(Float64(1.0 + x) + Float64(Float64(0.0625 / Float64(x * x)) + Float64(x + Float64(0.5 + Float64(-0.125 / x)))))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.43) tmp = ((x ^ -0.5) + (x * 0.5)) + -1.0; else tmp = ((1.0 + (x - x)) / sqrt(x)) / ((1.0 + x) + ((0.0625 / (x * x)) + (x + (0.5 + (-0.125 / x))))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.43], N[(N[(N[Power[x, -0.5], $MachinePrecision] + N[(x * 0.5), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[(1.0 + N[(x - x), $MachinePrecision]), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + x), $MachinePrecision] + N[(N[(0.0625 / N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(x + N[(0.5 + N[(-0.125 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.43:\\
\;\;\;\;\left({x}^{-0.5} + x \cdot 0.5\right) + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \left(x - x\right)}{\sqrt{x}}}{\left(1 + x\right) + \left(\frac{0.0625}{x \cdot x} + \left(x + \left(0.5 + \frac{-0.125}{x}\right)\right)\right)}\\
\end{array}
\end{array}
if x < 0.429999999999999993Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.5%
if 0.429999999999999993 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
flip--39.1%
add-sqr-sqrt39.9%
+-commutative39.9%
add-sqr-sqrt40.3%
associate--l+40.3%
+-commutative40.3%
Applied egg-rr40.3%
div-inv40.3%
sqrt-prod40.4%
+-commutative40.4%
times-frac40.3%
Applied egg-rr40.3%
associate-/l/40.3%
associate-*r/40.4%
metadata-eval40.4%
times-frac40.4%
*-rgt-identity40.4%
*-rgt-identity40.4%
associate-+r-40.3%
+-commutative40.3%
associate--l+99.3%
distribute-lft-in99.3%
rem-square-sqrt99.5%
+-commutative99.5%
+-commutative99.5%
Simplified99.5%
Taylor expanded in x around inf 98.9%
Simplified98.9%
Final simplification99.2%
(FPCore (x) :precision binary64 (if (<= x 0.43) (+ (+ (pow x -0.5) (* x 0.5)) -1.0) (/ (/ (+ 1.0 (- x x)) (sqrt x)) (+ (+ 1.0 x) (+ x (+ 0.5 (/ -0.125 x)))))))
double code(double x) {
double tmp;
if (x <= 0.43) {
tmp = (pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / sqrt(x)) / ((1.0 + x) + (x + (0.5 + (-0.125 / x))));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.43d0) then
tmp = ((x ** (-0.5d0)) + (x * 0.5d0)) + (-1.0d0)
else
tmp = ((1.0d0 + (x - x)) / sqrt(x)) / ((1.0d0 + x) + (x + (0.5d0 + ((-0.125d0) / x))))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.43) {
tmp = (Math.pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / Math.sqrt(x)) / ((1.0 + x) + (x + (0.5 + (-0.125 / x))));
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.43: tmp = (math.pow(x, -0.5) + (x * 0.5)) + -1.0 else: tmp = ((1.0 + (x - x)) / math.sqrt(x)) / ((1.0 + x) + (x + (0.5 + (-0.125 / x)))) return tmp
function code(x) tmp = 0.0 if (x <= 0.43) tmp = Float64(Float64((x ^ -0.5) + Float64(x * 0.5)) + -1.0); else tmp = Float64(Float64(Float64(1.0 + Float64(x - x)) / sqrt(x)) / Float64(Float64(1.0 + x) + Float64(x + Float64(0.5 + Float64(-0.125 / x))))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.43) tmp = ((x ^ -0.5) + (x * 0.5)) + -1.0; else tmp = ((1.0 + (x - x)) / sqrt(x)) / ((1.0 + x) + (x + (0.5 + (-0.125 / x)))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.43], N[(N[(N[Power[x, -0.5], $MachinePrecision] + N[(x * 0.5), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[(1.0 + N[(x - x), $MachinePrecision]), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + x), $MachinePrecision] + N[(x + N[(0.5 + N[(-0.125 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.43:\\
\;\;\;\;\left({x}^{-0.5} + x \cdot 0.5\right) + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \left(x - x\right)}{\sqrt{x}}}{\left(1 + x\right) + \left(x + \left(0.5 + \frac{-0.125}{x}\right)\right)}\\
\end{array}
\end{array}
if x < 0.429999999999999993Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.5%
if 0.429999999999999993 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
flip--39.1%
add-sqr-sqrt39.9%
+-commutative39.9%
add-sqr-sqrt40.3%
associate--l+40.3%
+-commutative40.3%
Applied egg-rr40.3%
div-inv40.3%
sqrt-prod40.4%
+-commutative40.4%
times-frac40.3%
Applied egg-rr40.3%
associate-/l/40.3%
associate-*r/40.4%
metadata-eval40.4%
times-frac40.4%
*-rgt-identity40.4%
*-rgt-identity40.4%
associate-+r-40.3%
+-commutative40.3%
associate--l+99.3%
distribute-lft-in99.3%
rem-square-sqrt99.5%
+-commutative99.5%
+-commutative99.5%
Simplified99.5%
Taylor expanded in x around inf 98.8%
associate--l+98.8%
*-commutative98.8%
cancel-sign-sub-inv98.8%
*-lft-identity98.8%
metadata-eval98.8%
rem-square-sqrt0.0%
unpow20.0%
associate-*r*0.0%
distribute-neg-frac0.0%
metadata-eval0.0%
metadata-eval0.0%
rem-square-sqrt0.0%
unpow20.0%
associate-/r*0.0%
*-commutative0.0%
+-commutative0.0%
+-commutative0.0%
Simplified98.8%
Final simplification99.2%
(FPCore (x) :precision binary64 (if (<= x 0.43) (+ (+ (pow x -0.5) (* x 0.5)) -1.0) (/ (/ (+ 1.0 (- x x)) (sqrt x)) (+ 1.5 (- (* x 2.0) (/ 0.125 x))))))
double code(double x) {
double tmp;
if (x <= 0.43) {
tmp = (pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x)));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.43d0) then
tmp = ((x ** (-0.5d0)) + (x * 0.5d0)) + (-1.0d0)
else
tmp = ((1.0d0 + (x - x)) / sqrt(x)) / (1.5d0 + ((x * 2.0d0) - (0.125d0 / x)))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.43) {
tmp = (Math.pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / Math.sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x)));
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.43: tmp = (math.pow(x, -0.5) + (x * 0.5)) + -1.0 else: tmp = ((1.0 + (x - x)) / math.sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x))) return tmp
function code(x) tmp = 0.0 if (x <= 0.43) tmp = Float64(Float64((x ^ -0.5) + Float64(x * 0.5)) + -1.0); else tmp = Float64(Float64(Float64(1.0 + Float64(x - x)) / sqrt(x)) / Float64(1.5 + Float64(Float64(x * 2.0) - Float64(0.125 / x)))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.43) tmp = ((x ^ -0.5) + (x * 0.5)) + -1.0; else tmp = ((1.0 + (x - x)) / sqrt(x)) / (1.5 + ((x * 2.0) - (0.125 / x))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.43], N[(N[(N[Power[x, -0.5], $MachinePrecision] + N[(x * 0.5), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[(1.0 + N[(x - x), $MachinePrecision]), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] / N[(1.5 + N[(N[(x * 2.0), $MachinePrecision] - N[(0.125 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.43:\\
\;\;\;\;\left({x}^{-0.5} + x \cdot 0.5\right) + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \left(x - x\right)}{\sqrt{x}}}{1.5 + \left(x \cdot 2 - \frac{0.125}{x}\right)}\\
\end{array}
\end{array}
if x < 0.429999999999999993Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.5%
if 0.429999999999999993 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
flip--39.1%
add-sqr-sqrt39.9%
+-commutative39.9%
add-sqr-sqrt40.3%
associate--l+40.3%
+-commutative40.3%
Applied egg-rr40.3%
div-inv40.3%
sqrt-prod40.4%
+-commutative40.4%
times-frac40.3%
Applied egg-rr40.3%
associate-/l/40.3%
associate-*r/40.4%
metadata-eval40.4%
times-frac40.4%
*-rgt-identity40.4%
*-rgt-identity40.4%
associate-+r-40.3%
+-commutative40.3%
associate--l+99.3%
distribute-lft-in99.3%
rem-square-sqrt99.5%
+-commutative99.5%
+-commutative99.5%
Simplified99.5%
Taylor expanded in x around inf 98.8%
associate--l+98.8%
*-commutative98.8%
associate-*r/98.8%
metadata-eval98.8%
Simplified98.8%
Final simplification99.2%
(FPCore (x) :precision binary64 (if (<= x 0.4) (+ (+ (pow x -0.5) (* x 0.5)) -1.0) (/ (/ (+ 1.0 (- x x)) (sqrt x)) (+ 1.5 (* x 2.0)))))
double code(double x) {
double tmp;
if (x <= 0.4) {
tmp = (pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / sqrt(x)) / (1.5 + (x * 2.0));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.4d0) then
tmp = ((x ** (-0.5d0)) + (x * 0.5d0)) + (-1.0d0)
else
tmp = ((1.0d0 + (x - x)) / sqrt(x)) / (1.5d0 + (x * 2.0d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.4) {
tmp = (Math.pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((1.0 + (x - x)) / Math.sqrt(x)) / (1.5 + (x * 2.0));
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.4: tmp = (math.pow(x, -0.5) + (x * 0.5)) + -1.0 else: tmp = ((1.0 + (x - x)) / math.sqrt(x)) / (1.5 + (x * 2.0)) return tmp
function code(x) tmp = 0.0 if (x <= 0.4) tmp = Float64(Float64((x ^ -0.5) + Float64(x * 0.5)) + -1.0); else tmp = Float64(Float64(Float64(1.0 + Float64(x - x)) / sqrt(x)) / Float64(1.5 + Float64(x * 2.0))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.4) tmp = ((x ^ -0.5) + (x * 0.5)) + -1.0; else tmp = ((1.0 + (x - x)) / sqrt(x)) / (1.5 + (x * 2.0)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.4], N[(N[(N[Power[x, -0.5], $MachinePrecision] + N[(x * 0.5), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[(1.0 + N[(x - x), $MachinePrecision]), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision] / N[(1.5 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.4:\\
\;\;\;\;\left({x}^{-0.5} + x \cdot 0.5\right) + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{1 + \left(x - x\right)}{\sqrt{x}}}{1.5 + x \cdot 2}\\
\end{array}
\end{array}
if x < 0.40000000000000002Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.5%
if 0.40000000000000002 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
flip--39.1%
add-sqr-sqrt39.9%
+-commutative39.9%
add-sqr-sqrt40.3%
associate--l+40.3%
+-commutative40.3%
Applied egg-rr40.3%
div-inv40.3%
sqrt-prod40.4%
+-commutative40.4%
times-frac40.3%
Applied egg-rr40.3%
associate-/l/40.3%
associate-*r/40.4%
metadata-eval40.4%
times-frac40.4%
*-rgt-identity40.4%
*-rgt-identity40.4%
associate-+r-40.3%
+-commutative40.3%
associate--l+99.3%
distribute-lft-in99.3%
rem-square-sqrt99.5%
+-commutative99.5%
+-commutative99.5%
Simplified99.5%
Taylor expanded in x around inf 98.6%
+-commutative98.6%
*-commutative98.6%
Simplified98.6%
Final simplification99.1%
(FPCore (x) :precision binary64 (if (<= x 1.1) (+ (+ (pow x -0.5) (* x 0.5)) -1.0) (/ (- (/ 0.5 x) (/ 0.375 (* x x))) (sqrt x))))
double code(double x) {
double tmp;
if (x <= 1.1) {
tmp = (pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((0.5 / x) - (0.375 / (x * x))) / sqrt(x);
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 1.1d0) then
tmp = ((x ** (-0.5d0)) + (x * 0.5d0)) + (-1.0d0)
else
tmp = ((0.5d0 / x) - (0.375d0 / (x * x))) / sqrt(x)
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 1.1) {
tmp = (Math.pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = ((0.5 / x) - (0.375 / (x * x))) / Math.sqrt(x);
}
return tmp;
}
def code(x): tmp = 0 if x <= 1.1: tmp = (math.pow(x, -0.5) + (x * 0.5)) + -1.0 else: tmp = ((0.5 / x) - (0.375 / (x * x))) / math.sqrt(x) return tmp
function code(x) tmp = 0.0 if (x <= 1.1) tmp = Float64(Float64((x ^ -0.5) + Float64(x * 0.5)) + -1.0); else tmp = Float64(Float64(Float64(0.5 / x) - Float64(0.375 / Float64(x * x))) / sqrt(x)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 1.1) tmp = ((x ^ -0.5) + (x * 0.5)) + -1.0; else tmp = ((0.5 / x) - (0.375 / (x * x))) / sqrt(x); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 1.1], N[(N[(N[Power[x, -0.5], $MachinePrecision] + N[(x * 0.5), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[(0.5 / x), $MachinePrecision] - N[(0.375 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 1.1:\\
\;\;\;\;\left({x}^{-0.5} + x \cdot 0.5\right) + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{0.5}{x} - \frac{0.375}{x \cdot x}}{\sqrt{x}}\\
\end{array}
\end{array}
if x < 1.1000000000000001Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.5%
if 1.1000000000000001 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
add-cube-cbrt38.7%
sqrt-prod38.7%
times-frac38.7%
pow238.7%
+-commutative38.7%
+-commutative38.7%
+-commutative38.7%
Applied egg-rr38.7%
associate-*l/38.7%
associate-*r/38.7%
unpow238.7%
rem-3cbrt-lft38.8%
div-sub38.8%
*-inverses38.8%
Simplified38.8%
Taylor expanded in x around inf 98.5%
associate-*r/98.5%
metadata-eval98.5%
unpow298.5%
associate-*r/98.5%
metadata-eval98.5%
Simplified98.5%
Final simplification99.0%
(FPCore (x) :precision binary64 (if (<= x 1.0) (+ (+ (pow x -0.5) (* x 0.5)) -1.0) (/ (/ 0.5 x) (sqrt x))))
double code(double x) {
double tmp;
if (x <= 1.0) {
tmp = (pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = (0.5 / x) / sqrt(x);
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 1.0d0) then
tmp = ((x ** (-0.5d0)) + (x * 0.5d0)) + (-1.0d0)
else
tmp = (0.5d0 / x) / sqrt(x)
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 1.0) {
tmp = (Math.pow(x, -0.5) + (x * 0.5)) + -1.0;
} else {
tmp = (0.5 / x) / Math.sqrt(x);
}
return tmp;
}
def code(x): tmp = 0 if x <= 1.0: tmp = (math.pow(x, -0.5) + (x * 0.5)) + -1.0 else: tmp = (0.5 / x) / math.sqrt(x) return tmp
function code(x) tmp = 0.0 if (x <= 1.0) tmp = Float64(Float64((x ^ -0.5) + Float64(x * 0.5)) + -1.0); else tmp = Float64(Float64(0.5 / x) / sqrt(x)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 1.0) tmp = ((x ^ -0.5) + (x * 0.5)) + -1.0; else tmp = (0.5 / x) / sqrt(x); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 1.0], N[(N[(N[Power[x, -0.5], $MachinePrecision] + N[(x * 0.5), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(0.5 / x), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 1:\\
\;\;\;\;\left({x}^{-0.5} + x \cdot 0.5\right) + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{0.5}{x}}{\sqrt{x}}\\
\end{array}
\end{array}
if x < 1Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.5%
if 1 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
add-cube-cbrt38.7%
sqrt-prod38.7%
times-frac38.7%
pow238.7%
+-commutative38.7%
+-commutative38.7%
+-commutative38.7%
Applied egg-rr38.7%
associate-*l/38.7%
associate-*r/38.7%
unpow238.7%
rem-3cbrt-lft38.8%
div-sub38.8%
*-inverses38.8%
Simplified38.8%
Taylor expanded in x around inf 97.4%
Final simplification98.5%
(FPCore (x) :precision binary64 (if (<= x 0.66) (+ (pow x -0.5) -1.0) (/ 0.5 (* x (sqrt x)))))
double code(double x) {
double tmp;
if (x <= 0.66) {
tmp = pow(x, -0.5) + -1.0;
} else {
tmp = 0.5 / (x * sqrt(x));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.66d0) then
tmp = (x ** (-0.5d0)) + (-1.0d0)
else
tmp = 0.5d0 / (x * sqrt(x))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.66) {
tmp = Math.pow(x, -0.5) + -1.0;
} else {
tmp = 0.5 / (x * Math.sqrt(x));
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.66: tmp = math.pow(x, -0.5) + -1.0 else: tmp = 0.5 / (x * math.sqrt(x)) return tmp
function code(x) tmp = 0.0 if (x <= 0.66) tmp = Float64((x ^ -0.5) + -1.0); else tmp = Float64(0.5 / Float64(x * sqrt(x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.66) tmp = (x ^ -0.5) + -1.0; else tmp = 0.5 / (x * sqrt(x)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.66], N[(N[Power[x, -0.5], $MachinePrecision] + -1.0), $MachinePrecision], N[(0.5 / N[(x * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.66:\\
\;\;\;\;{x}^{-0.5} + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{0.5}{x \cdot \sqrt{x}}\\
\end{array}
\end{array}
if x < 0.660000000000000031Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.3%
if 0.660000000000000031 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
add-cube-cbrt38.7%
sqrt-prod38.7%
times-frac38.7%
pow238.7%
+-commutative38.7%
+-commutative38.7%
+-commutative38.7%
Applied egg-rr38.7%
associate-*l/38.7%
associate-*r/38.7%
unpow238.7%
rem-3cbrt-lft38.8%
div-sub38.8%
*-inverses38.8%
Simplified38.8%
Taylor expanded in x around inf 97.4%
add-cube-cbrt96.3%
pow396.3%
associate-/l/95.6%
cbrt-div95.6%
add-sqr-sqrt95.4%
cube-unmult95.4%
pow395.4%
add-cbrt-cube96.5%
Applied egg-rr96.5%
cube-div95.7%
rem-cube-cbrt96.2%
unpow396.3%
rem-square-sqrt96.6%
Simplified96.6%
Final simplification98.0%
(FPCore (x) :precision binary64 (if (<= x 0.66) (+ (pow x -0.5) -1.0) (/ (/ 0.5 x) (sqrt x))))
double code(double x) {
double tmp;
if (x <= 0.66) {
tmp = pow(x, -0.5) + -1.0;
} else {
tmp = (0.5 / x) / sqrt(x);
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.66d0) then
tmp = (x ** (-0.5d0)) + (-1.0d0)
else
tmp = (0.5d0 / x) / sqrt(x)
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.66) {
tmp = Math.pow(x, -0.5) + -1.0;
} else {
tmp = (0.5 / x) / Math.sqrt(x);
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.66: tmp = math.pow(x, -0.5) + -1.0 else: tmp = (0.5 / x) / math.sqrt(x) return tmp
function code(x) tmp = 0.0 if (x <= 0.66) tmp = Float64((x ^ -0.5) + -1.0); else tmp = Float64(Float64(0.5 / x) / sqrt(x)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.66) tmp = (x ^ -0.5) + -1.0; else tmp = (0.5 / x) / sqrt(x); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.66], N[(N[Power[x, -0.5], $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(0.5 / x), $MachinePrecision] / N[Sqrt[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.66:\\
\;\;\;\;{x}^{-0.5} + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{0.5}{x}}{\sqrt{x}}\\
\end{array}
\end{array}
if x < 0.660000000000000031Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.3%
if 0.660000000000000031 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
add-cube-cbrt38.7%
sqrt-prod38.7%
times-frac38.7%
pow238.7%
+-commutative38.7%
+-commutative38.7%
+-commutative38.7%
Applied egg-rr38.7%
associate-*l/38.7%
associate-*r/38.7%
unpow238.7%
rem-3cbrt-lft38.8%
div-sub38.8%
*-inverses38.8%
Simplified38.8%
Taylor expanded in x around inf 97.4%
Final simplification98.4%
(FPCore (x) :precision binary64 (if (<= x 0.62) (+ (pow x -0.5) -1.0) (- (/ 1.0 x) (/ 0.5 (* x x)))))
double code(double x) {
double tmp;
if (x <= 0.62) {
tmp = pow(x, -0.5) + -1.0;
} else {
tmp = (1.0 / x) - (0.5 / (x * x));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.62d0) then
tmp = (x ** (-0.5d0)) + (-1.0d0)
else
tmp = (1.0d0 / x) - (0.5d0 / (x * x))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.62) {
tmp = Math.pow(x, -0.5) + -1.0;
} else {
tmp = (1.0 / x) - (0.5 / (x * x));
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.62: tmp = math.pow(x, -0.5) + -1.0 else: tmp = (1.0 / x) - (0.5 / (x * x)) return tmp
function code(x) tmp = 0.0 if (x <= 0.62) tmp = Float64((x ^ -0.5) + -1.0); else tmp = Float64(Float64(1.0 / x) - Float64(0.5 / Float64(x * x))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.62) tmp = (x ^ -0.5) + -1.0; else tmp = (1.0 / x) - (0.5 / (x * x)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.62], N[(N[Power[x, -0.5], $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(1.0 / x), $MachinePrecision] - N[(0.5 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.62:\\
\;\;\;\;{x}^{-0.5} + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{x} - \frac{0.5}{x \cdot x}\\
\end{array}
\end{array}
if x < 0.619999999999999996Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.3%
if 0.619999999999999996 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
Taylor expanded in x around inf 37.8%
+-commutative37.8%
Simplified37.8%
Taylor expanded in x around 0 7.8%
Taylor expanded in x around inf 7.8%
associate-*r/7.8%
metadata-eval7.8%
unpow27.8%
Simplified7.8%
Final simplification55.7%
(FPCore (x) :precision binary64 (if (<= x 0.66) (+ (pow x -0.5) -1.0) (/ 0.5 (pow x 1.5))))
double code(double x) {
double tmp;
if (x <= 0.66) {
tmp = pow(x, -0.5) + -1.0;
} else {
tmp = 0.5 / pow(x, 1.5);
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= 0.66d0) then
tmp = (x ** (-0.5d0)) + (-1.0d0)
else
tmp = 0.5d0 / (x ** 1.5d0)
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= 0.66) {
tmp = Math.pow(x, -0.5) + -1.0;
} else {
tmp = 0.5 / Math.pow(x, 1.5);
}
return tmp;
}
def code(x): tmp = 0 if x <= 0.66: tmp = math.pow(x, -0.5) + -1.0 else: tmp = 0.5 / math.pow(x, 1.5) return tmp
function code(x) tmp = 0.0 if (x <= 0.66) tmp = Float64((x ^ -0.5) + -1.0); else tmp = Float64(0.5 / (x ^ 1.5)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= 0.66) tmp = (x ^ -0.5) + -1.0; else tmp = 0.5 / (x ^ 1.5); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, 0.66], N[(N[Power[x, -0.5], $MachinePrecision] + -1.0), $MachinePrecision], N[(0.5 / N[Power[x, 1.5], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.66:\\
\;\;\;\;{x}^{-0.5} + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{0.5}{{x}^{1.5}}\\
\end{array}
\end{array}
if x < 0.660000000000000031Initial program 99.7%
*-un-lft-identity99.7%
clear-num99.7%
associate-/r/99.7%
prod-diff99.7%
*-un-lft-identity99.7%
fma-neg99.7%
*-un-lft-identity99.7%
inv-pow99.7%
sqrt-pow2100.0%
metadata-eval100.0%
pow1/2100.0%
pow-flip100.0%
+-commutative100.0%
metadata-eval100.0%
Applied egg-rr100.0%
fma-udef100.0%
distribute-lft1-in100.0%
metadata-eval100.0%
mul0-lft100.0%
+-rgt-identity100.0%
Simplified100.0%
Taylor expanded in x around 0 99.3%
if 0.660000000000000031 < x Initial program 38.7%
frac-sub38.8%
*-un-lft-identity38.8%
+-commutative38.8%
*-rgt-identity38.8%
sqrt-unprod38.8%
+-commutative38.8%
Applied egg-rr38.8%
add-cube-cbrt38.7%
sqrt-prod38.7%
times-frac38.7%
pow238.7%
+-commutative38.7%
+-commutative38.7%
+-commutative38.7%
Applied egg-rr38.7%
associate-*l/38.7%
associate-*r/38.7%
unpow238.7%
rem-3cbrt-lft38.8%
div-sub38.8%
*-inverses38.8%
Simplified38.8%
Taylor expanded in x around inf 97.4%
expm1-log1p-u97.4%
expm1-udef36.8%
associate-/l/36.8%
pow1/236.8%
pow-plus36.8%
metadata-eval36.8%
Applied egg-rr36.8%
expm1-def96.6%
expm1-log1p96.6%
Simplified96.6%
Final simplification98.0%
(FPCore (x) :precision binary64 (pow x -0.5))
double code(double x) {
return pow(x, -0.5);
}
real(8) function code(x)
real(8), intent (in) :: x
code = x ** (-0.5d0)
end function
public static double code(double x) {
return Math.pow(x, -0.5);
}
def code(x): return math.pow(x, -0.5)
function code(x) return x ^ -0.5 end
function tmp = code(x) tmp = x ^ -0.5; end
code[x_] := N[Power[x, -0.5], $MachinePrecision]
\begin{array}{l}
\\
{x}^{-0.5}
\end{array}
Initial program 70.6%
sub-neg70.6%
+-commutative70.6%
add-cube-cbrt57.2%
distribute-lft-neg-in57.2%
fma-def56.0%
Applied egg-rr56.3%
Taylor expanded in x around inf 52.9%
inv-pow52.9%
sqrt-pow152.9%
metadata-eval52.9%
expm1-log1p-u49.3%
expm1-udef63.9%
Applied egg-rr63.9%
expm1-def49.3%
expm1-log1p52.9%
Simplified52.9%
Final simplification52.9%
(FPCore (x) :precision binary64 (/ 1.0 (+ x 0.5)))
double code(double x) {
return 1.0 / (x + 0.5);
}
real(8) function code(x)
real(8), intent (in) :: x
code = 1.0d0 / (x + 0.5d0)
end function
public static double code(double x) {
return 1.0 / (x + 0.5);
}
def code(x): return 1.0 / (x + 0.5)
function code(x) return Float64(1.0 / Float64(x + 0.5)) end
function tmp = code(x) tmp = 1.0 / (x + 0.5); end
code[x_] := N[(1.0 / N[(x + 0.5), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{x + 0.5}
\end{array}
Initial program 70.6%
frac-sub70.6%
*-un-lft-identity70.6%
+-commutative70.6%
*-rgt-identity70.6%
sqrt-unprod70.6%
+-commutative70.6%
Applied egg-rr70.6%
Taylor expanded in x around inf 21.6%
+-commutative21.6%
Simplified21.6%
Taylor expanded in x around 0 7.3%
Final simplification7.3%
(FPCore (x) :precision binary64 (/ 1.0 x))
double code(double x) {
return 1.0 / x;
}
real(8) function code(x)
real(8), intent (in) :: x
code = 1.0d0 / x
end function
public static double code(double x) {
return 1.0 / x;
}
def code(x): return 1.0 / x
function code(x) return Float64(1.0 / x) end
function tmp = code(x) tmp = 1.0 / x; end
code[x_] := N[(1.0 / x), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{x}
\end{array}
Initial program 70.6%
frac-sub70.6%
*-un-lft-identity70.6%
+-commutative70.6%
*-rgt-identity70.6%
sqrt-unprod70.6%
+-commutative70.6%
Applied egg-rr70.6%
Taylor expanded in x around inf 21.6%
+-commutative21.6%
Simplified21.6%
Taylor expanded in x around 0 7.3%
Taylor expanded in x around inf 7.3%
Final simplification7.3%
(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 70.6%
frac-sub70.6%
*-un-lft-identity70.6%
+-commutative70.6%
*-rgt-identity70.6%
sqrt-unprod70.6%
+-commutative70.6%
Applied egg-rr70.6%
Taylor expanded in x around inf 21.6%
+-commutative21.6%
Simplified21.6%
Taylor expanded in x around 0 5.8%
Final simplification5.8%
(FPCore (x) :precision binary64 (/ 1.0 (+ (* (+ x 1.0) (sqrt x)) (* x (sqrt (+ x 1.0))))))
double code(double x) {
return 1.0 / (((x + 1.0) * sqrt(x)) + (x * sqrt((x + 1.0))));
}
real(8) function code(x)
real(8), intent (in) :: x
code = 1.0d0 / (((x + 1.0d0) * sqrt(x)) + (x * sqrt((x + 1.0d0))))
end function
public static double code(double x) {
return 1.0 / (((x + 1.0) * Math.sqrt(x)) + (x * Math.sqrt((x + 1.0))));
}
def code(x): return 1.0 / (((x + 1.0) * math.sqrt(x)) + (x * math.sqrt((x + 1.0))))
function code(x) return Float64(1.0 / Float64(Float64(Float64(x + 1.0) * sqrt(x)) + Float64(x * sqrt(Float64(x + 1.0))))) end
function tmp = code(x) tmp = 1.0 / (((x + 1.0) * sqrt(x)) + (x * sqrt((x + 1.0)))); end
code[x_] := N[(1.0 / N[(N[(N[(x + 1.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(x * N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{\left(x + 1\right) \cdot \sqrt{x} + x \cdot \sqrt{x + 1}}
\end{array}
herbie shell --seed 2023200
(FPCore (x)
:name "2isqrt (example 3.6)"
:precision binary64
:herbie-target
(/ 1.0 (+ (* (+ x 1.0) (sqrt x)) (* x (sqrt (+ x 1.0)))))
(- (/ 1.0 (sqrt x)) (/ 1.0 (sqrt (+ x 1.0)))))