
(FPCore (x) :precision binary64 (- 1.0 (sqrt (* 0.5 (+ 1.0 (/ 1.0 (hypot 1.0 x)))))))
double code(double x) {
return 1.0 - sqrt((0.5 * (1.0 + (1.0 / hypot(1.0, x)))));
}
public static double code(double x) {
return 1.0 - Math.sqrt((0.5 * (1.0 + (1.0 / Math.hypot(1.0, x)))));
}
def code(x): return 1.0 - math.sqrt((0.5 * (1.0 + (1.0 / math.hypot(1.0, x)))))
function code(x) return Float64(1.0 - sqrt(Float64(0.5 * Float64(1.0 + Float64(1.0 / hypot(1.0, x)))))) end
function tmp = code(x) tmp = 1.0 - sqrt((0.5 * (1.0 + (1.0 / hypot(1.0, x))))); end
code[x_] := N[(1.0 - N[Sqrt[N[(0.5 * N[(1.0 + N[(1.0 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \sqrt{0.5 \cdot \left(1 + \frac{1}{\mathsf{hypot}\left(1, x\right)}\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (- 1.0 (sqrt (* 0.5 (+ 1.0 (/ 1.0 (hypot 1.0 x)))))))
double code(double x) {
return 1.0 - sqrt((0.5 * (1.0 + (1.0 / hypot(1.0, x)))));
}
public static double code(double x) {
return 1.0 - Math.sqrt((0.5 * (1.0 + (1.0 / Math.hypot(1.0, x)))));
}
def code(x): return 1.0 - math.sqrt((0.5 * (1.0 + (1.0 / math.hypot(1.0, x)))))
function code(x) return Float64(1.0 - sqrt(Float64(0.5 * Float64(1.0 + Float64(1.0 / hypot(1.0, x)))))) end
function tmp = code(x) tmp = 1.0 - sqrt((0.5 * (1.0 + (1.0 / hypot(1.0, x))))); end
code[x_] := N[(1.0 - N[Sqrt[N[(0.5 * N[(1.0 + N[(1.0 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 - \sqrt{0.5 \cdot \left(1 + \frac{1}{\mathsf{hypot}\left(1, x\right)}\right)}
\end{array}
(FPCore (x)
:precision binary64
(let* ((t_0 (/ -0.5 (hypot 1.0 x))) (t_1 (- 0.5 t_0)) (t_2 (pow t_1 2.0)))
(if (<= (hypot 1.0 x) 1.0005)
(* (* (fma (fma 0.0673828125 (* x x) -0.0859375) (* x x) 0.125) x) x)
(/
(fma
(* (pow t_1 3.0) (- (+ t_2 0.5) (/ 0.5 (hypot 1.0 x))))
(pow (- (pow (+ t_2 1.0) 2.0) t_2) -1.0)
(/ -1.0 (- (+ 1.5 t_2) t_0)))
(- -1.0 (sqrt t_1))))))
double code(double x) {
double t_0 = -0.5 / hypot(1.0, x);
double t_1 = 0.5 - t_0;
double t_2 = pow(t_1, 2.0);
double tmp;
if (hypot(1.0, x) <= 1.0005) {
tmp = (fma(fma(0.0673828125, (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = fma((pow(t_1, 3.0) * ((t_2 + 0.5) - (0.5 / hypot(1.0, x)))), pow((pow((t_2 + 1.0), 2.0) - t_2), -1.0), (-1.0 / ((1.5 + t_2) - t_0))) / (-1.0 - sqrt(t_1));
}
return tmp;
}
function code(x) t_0 = Float64(-0.5 / hypot(1.0, x)) t_1 = Float64(0.5 - t_0) t_2 = t_1 ^ 2.0 tmp = 0.0 if (hypot(1.0, x) <= 1.0005) tmp = Float64(Float64(fma(fma(0.0673828125, Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = Float64(fma(Float64((t_1 ^ 3.0) * Float64(Float64(t_2 + 0.5) - Float64(0.5 / hypot(1.0, x)))), (Float64((Float64(t_2 + 1.0) ^ 2.0) - t_2) ^ -1.0), Float64(-1.0 / Float64(Float64(1.5 + t_2) - t_0))) / Float64(-1.0 - sqrt(t_1))); end return tmp end
code[x_] := Block[{t$95$0 = N[(-0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.5 - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[Power[t$95$1, 2.0], $MachinePrecision]}, If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 1.0005], N[(N[(N[(N[(0.0673828125 * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(N[Power[t$95$1, 3.0], $MachinePrecision] * N[(N[(t$95$2 + 0.5), $MachinePrecision] - N[(0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[Power[N[(t$95$2 + 1.0), $MachinePrecision], 2.0], $MachinePrecision] - t$95$2), $MachinePrecision], -1.0], $MachinePrecision] + N[(-1.0 / N[(N[(1.5 + t$95$2), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(-1.0 - N[Sqrt[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-0.5}{\mathsf{hypot}\left(1, x\right)}\\
t_1 := 0.5 - t\_0\\
t_2 := {t\_1}^{2}\\
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 1.0005:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(0.0673828125, x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left({t\_1}^{3} \cdot \left(\left(t\_2 + 0.5\right) - \frac{0.5}{\mathsf{hypot}\left(1, x\right)}\right), {\left({\left(t\_2 + 1\right)}^{2} - t\_2\right)}^{-1}, \frac{-1}{\left(1.5 + t\_2\right) - t\_0}\right)}{-1 - \sqrt{t\_1}}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 1.00049999999999994Initial program 54.7%
Applied rewrites54.7%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 1.00049999999999994 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.3%
Applied rewrites99.8%
lift--.f64N/A
flip3--N/A
metadata-evalN/A
div-subN/A
lower--.f64N/A
Applied rewrites99.8%
lift--.f64N/A
sub-negN/A
Applied rewrites99.9%
lift-fma.f64N/A
Applied rewrites99.9%
Final simplification100.0%
(FPCore (x)
:precision binary64
(let* ((t_0 (/ -0.5 (hypot 1.0 x))) (t_1 (- 0.5 t_0)) (t_2 (pow t_1 2.0)))
(if (<= (hypot 1.0 x) 1.0005)
(* (* (fma (fma 0.0673828125 (* x x) -0.0859375) (* x x) 0.125) x) x)
(/
(fma
(pow t_1 3.0)
(/ (- (+ t_2 0.5) (/ 0.5 (hypot 1.0 x))) (- (pow (+ t_2 1.0) 2.0) t_2))
(/ -1.0 (- (+ 1.5 t_2) t_0)))
(- -1.0 (sqrt t_1))))))
double code(double x) {
double t_0 = -0.5 / hypot(1.0, x);
double t_1 = 0.5 - t_0;
double t_2 = pow(t_1, 2.0);
double tmp;
if (hypot(1.0, x) <= 1.0005) {
tmp = (fma(fma(0.0673828125, (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = fma(pow(t_1, 3.0), (((t_2 + 0.5) - (0.5 / hypot(1.0, x))) / (pow((t_2 + 1.0), 2.0) - t_2)), (-1.0 / ((1.5 + t_2) - t_0))) / (-1.0 - sqrt(t_1));
}
return tmp;
}
function code(x) t_0 = Float64(-0.5 / hypot(1.0, x)) t_1 = Float64(0.5 - t_0) t_2 = t_1 ^ 2.0 tmp = 0.0 if (hypot(1.0, x) <= 1.0005) tmp = Float64(Float64(fma(fma(0.0673828125, Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = Float64(fma((t_1 ^ 3.0), Float64(Float64(Float64(t_2 + 0.5) - Float64(0.5 / hypot(1.0, x))) / Float64((Float64(t_2 + 1.0) ^ 2.0) - t_2)), Float64(-1.0 / Float64(Float64(1.5 + t_2) - t_0))) / Float64(-1.0 - sqrt(t_1))); end return tmp end
code[x_] := Block[{t$95$0 = N[(-0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.5 - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[Power[t$95$1, 2.0], $MachinePrecision]}, If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 1.0005], N[(N[(N[(N[(0.0673828125 * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[Power[t$95$1, 3.0], $MachinePrecision] * N[(N[(N[(t$95$2 + 0.5), $MachinePrecision] - N[(0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[(t$95$2 + 1.0), $MachinePrecision], 2.0], $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / N[(N[(1.5 + t$95$2), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(-1.0 - N[Sqrt[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-0.5}{\mathsf{hypot}\left(1, x\right)}\\
t_1 := 0.5 - t\_0\\
t_2 := {t\_1}^{2}\\
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 1.0005:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(0.0673828125, x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left({t\_1}^{3}, \frac{\left(t\_2 + 0.5\right) - \frac{0.5}{\mathsf{hypot}\left(1, x\right)}}{{\left(t\_2 + 1\right)}^{2} - t\_2}, \frac{-1}{\left(1.5 + t\_2\right) - t\_0}\right)}{-1 - \sqrt{t\_1}}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 1.00049999999999994Initial program 54.7%
Applied rewrites54.7%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 1.00049999999999994 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.3%
Applied rewrites99.8%
lift--.f64N/A
flip3--N/A
metadata-evalN/A
div-subN/A
lower--.f64N/A
Applied rewrites99.8%
lift--.f64N/A
sub-negN/A
Applied rewrites99.9%
lift-fma.f64N/A
Applied rewrites99.9%
Final simplification100.0%
(FPCore (x)
:precision binary64
(let* ((t_0 (/ -0.5 (hypot 1.0 x)))
(t_1 (- 0.5 t_0))
(t_2 (- (+ 1.5 (pow t_1 2.0)) t_0))
(t_3 (fma -1.0 (sqrt t_1) -1.0)))
(if (<= (hypot 1.0 x) 1.0005)
(* (* (fma (fma 0.0673828125 (* x x) -0.0859375) (* x x) 0.125) x) x)
(fma (/ (pow t_1 3.0) t_2) (pow t_3 -1.0) (/ (- (pow t_2 -1.0)) t_3)))))
double code(double x) {
double t_0 = -0.5 / hypot(1.0, x);
double t_1 = 0.5 - t_0;
double t_2 = (1.5 + pow(t_1, 2.0)) - t_0;
double t_3 = fma(-1.0, sqrt(t_1), -1.0);
double tmp;
if (hypot(1.0, x) <= 1.0005) {
tmp = (fma(fma(0.0673828125, (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = fma((pow(t_1, 3.0) / t_2), pow(t_3, -1.0), (-pow(t_2, -1.0) / t_3));
}
return tmp;
}
function code(x) t_0 = Float64(-0.5 / hypot(1.0, x)) t_1 = Float64(0.5 - t_0) t_2 = Float64(Float64(1.5 + (t_1 ^ 2.0)) - t_0) t_3 = fma(-1.0, sqrt(t_1), -1.0) tmp = 0.0 if (hypot(1.0, x) <= 1.0005) tmp = Float64(Float64(fma(fma(0.0673828125, Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = fma(Float64((t_1 ^ 3.0) / t_2), (t_3 ^ -1.0), Float64(Float64(-(t_2 ^ -1.0)) / t_3)); end return tmp end
code[x_] := Block[{t$95$0 = N[(-0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.5 - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(1.5 + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]}, Block[{t$95$3 = N[(-1.0 * N[Sqrt[t$95$1], $MachinePrecision] + -1.0), $MachinePrecision]}, If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 1.0005], N[(N[(N[(N[(0.0673828125 * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[Power[t$95$1, 3.0], $MachinePrecision] / t$95$2), $MachinePrecision] * N[Power[t$95$3, -1.0], $MachinePrecision] + N[((-N[Power[t$95$2, -1.0], $MachinePrecision]) / t$95$3), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-0.5}{\mathsf{hypot}\left(1, x\right)}\\
t_1 := 0.5 - t\_0\\
t_2 := \left(1.5 + {t\_1}^{2}\right) - t\_0\\
t_3 := \mathsf{fma}\left(-1, \sqrt{t\_1}, -1\right)\\
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 1.0005:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(0.0673828125, x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{{t\_1}^{3}}{t\_2}, {t\_3}^{-1}, \frac{-{t\_2}^{-1}}{t\_3}\right)\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 1.00049999999999994Initial program 54.7%
Applied rewrites54.7%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 1.00049999999999994 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.3%
Applied rewrites99.8%
lift--.f64N/A
flip3--N/A
metadata-evalN/A
div-subN/A
lower--.f64N/A
Applied rewrites99.8%
lift-/.f64N/A
lift--.f64N/A
div-subN/A
Applied rewrites99.9%
Final simplification99.9%
(FPCore (x)
:precision binary64
(let* ((t_0 (/ -0.5 (hypot 1.0 x)))
(t_1 (- 0.5 t_0))
(t_2 (- (+ 1.5 (pow t_1 2.0)) t_0)))
(if (<= (hypot 1.0 x) 1.0005)
(* (* (fma (fma 0.0673828125 (* x x) -0.0859375) (* x x) 0.125) x) x)
(/ (+ (/ -1.0 t_2) (/ (pow t_1 3.0) t_2)) (- -1.0 (sqrt t_1))))))
double code(double x) {
double t_0 = -0.5 / hypot(1.0, x);
double t_1 = 0.5 - t_0;
double t_2 = (1.5 + pow(t_1, 2.0)) - t_0;
double tmp;
if (hypot(1.0, x) <= 1.0005) {
tmp = (fma(fma(0.0673828125, (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = ((-1.0 / t_2) + (pow(t_1, 3.0) / t_2)) / (-1.0 - sqrt(t_1));
}
return tmp;
}
function code(x) t_0 = Float64(-0.5 / hypot(1.0, x)) t_1 = Float64(0.5 - t_0) t_2 = Float64(Float64(1.5 + (t_1 ^ 2.0)) - t_0) tmp = 0.0 if (hypot(1.0, x) <= 1.0005) tmp = Float64(Float64(fma(fma(0.0673828125, Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = Float64(Float64(Float64(-1.0 / t_2) + Float64((t_1 ^ 3.0) / t_2)) / Float64(-1.0 - sqrt(t_1))); end return tmp end
code[x_] := Block[{t$95$0 = N[(-0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(0.5 - t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(1.5 + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]}, If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 1.0005], N[(N[(N[(N[(0.0673828125 * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(-1.0 / t$95$2), $MachinePrecision] + N[(N[Power[t$95$1, 3.0], $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision] / N[(-1.0 - N[Sqrt[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-0.5}{\mathsf{hypot}\left(1, x\right)}\\
t_1 := 0.5 - t\_0\\
t_2 := \left(1.5 + {t\_1}^{2}\right) - t\_0\\
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 1.0005:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(0.0673828125, x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{-1}{t\_2} + \frac{{t\_1}^{3}}{t\_2}}{-1 - \sqrt{t\_1}}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 1.00049999999999994Initial program 54.7%
Applied rewrites54.7%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 1.00049999999999994 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.3%
Applied rewrites99.8%
lift--.f64N/A
flip3--N/A
metadata-evalN/A
div-subN/A
lower--.f64N/A
Applied rewrites99.8%
lift--.f64N/A
sub-negN/A
lower-+.f64N/A
Applied rewrites99.9%
Final simplification99.9%
(FPCore (x)
:precision binary64
(let* ((t_0 (- 0.5 (/ -0.5 (hypot 1.0 x))))
(t_1 (fma -1.0 (sqrt t_0) -1.0))
(t_2 (/ t_1 t_0)))
(if (<= (hypot 1.0 x) 1.0005)
(* (* (fma (fma 0.0673828125 (* x x) -0.0859375) (* x x) 0.125) x) x)
(/ (- t_1 t_2) (* t_2 t_1)))))
double code(double x) {
double t_0 = 0.5 - (-0.5 / hypot(1.0, x));
double t_1 = fma(-1.0, sqrt(t_0), -1.0);
double t_2 = t_1 / t_0;
double tmp;
if (hypot(1.0, x) <= 1.0005) {
tmp = (fma(fma(0.0673828125, (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = (t_1 - t_2) / (t_2 * t_1);
}
return tmp;
}
function code(x) t_0 = Float64(0.5 - Float64(-0.5 / hypot(1.0, x))) t_1 = fma(-1.0, sqrt(t_0), -1.0) t_2 = Float64(t_1 / t_0) tmp = 0.0 if (hypot(1.0, x) <= 1.0005) tmp = Float64(Float64(fma(fma(0.0673828125, Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = Float64(Float64(t_1 - t_2) / Float64(t_2 * t_1)); end return tmp end
code[x_] := Block[{t$95$0 = N[(0.5 - N[(-0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(-1.0 * N[Sqrt[t$95$0], $MachinePrecision] + -1.0), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / t$95$0), $MachinePrecision]}, If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 1.0005], N[(N[(N[(N[(0.0673828125 * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(N[(t$95$1 - t$95$2), $MachinePrecision] / N[(t$95$2 * t$95$1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 0.5 - \frac{-0.5}{\mathsf{hypot}\left(1, x\right)}\\
t_1 := \mathsf{fma}\left(-1, \sqrt{t\_0}, -1\right)\\
t_2 := \frac{t\_1}{t\_0}\\
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 1.0005:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(0.0673828125, x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_1 - t\_2}{t\_2 \cdot t\_1}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 1.00049999999999994Initial program 54.7%
Applied rewrites54.7%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 1.00049999999999994 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.3%
Applied rewrites99.8%
lift-/.f64N/A
lift--.f64N/A
div-subN/A
clear-numN/A
frac-subN/A
lower-/.f64N/A
Applied rewrites99.9%
Final simplification99.9%
(FPCore (x)
:precision binary64
(let* ((t_0 (/ -0.5 (hypot 1.0 x))))
(if (<= (hypot 1.0 x) 1.0005)
(* (* (fma (fma 0.0673828125 (* x x) -0.0859375) (* x x) 0.125) x) x)
(/ (- (- t_0 0.5) -1.0) (+ (sqrt (- 0.5 t_0)) 1.0)))))
double code(double x) {
double t_0 = -0.5 / hypot(1.0, x);
double tmp;
if (hypot(1.0, x) <= 1.0005) {
tmp = (fma(fma(0.0673828125, (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = ((t_0 - 0.5) - -1.0) / (sqrt((0.5 - t_0)) + 1.0);
}
return tmp;
}
function code(x) t_0 = Float64(-0.5 / hypot(1.0, x)) tmp = 0.0 if (hypot(1.0, x) <= 1.0005) tmp = Float64(Float64(fma(fma(0.0673828125, Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = Float64(Float64(Float64(t_0 - 0.5) - -1.0) / Float64(sqrt(Float64(0.5 - t_0)) + 1.0)); end return tmp end
code[x_] := Block[{t$95$0 = N[(-0.5 / N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 1.0005], N[(N[(N[(N[(0.0673828125 * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(t$95$0 - 0.5), $MachinePrecision] - -1.0), $MachinePrecision] / N[(N[Sqrt[N[(0.5 - t$95$0), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{-0.5}{\mathsf{hypot}\left(1, x\right)}\\
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 1.0005:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(0.0673828125, x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(t\_0 - 0.5\right) - -1}{\sqrt{0.5 - t\_0} + 1}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 1.00049999999999994Initial program 54.7%
Applied rewrites54.7%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 1.00049999999999994 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.3%
Applied rewrites99.8%
Final simplification99.9%
(FPCore (x)
:precision binary64
(if (<= (hypot 1.0 x) 2.0)
(*
(*
(fma
(fma (fma -0.056243896484375 (* x x) 0.0673828125) (* x x) -0.0859375)
(* x x)
0.125)
x)
x)
(/ 0.5 (+ (sqrt 0.5) 1.0))))
double code(double x) {
double tmp;
if (hypot(1.0, x) <= 2.0) {
tmp = (fma(fma(fma(-0.056243896484375, (x * x), 0.0673828125), (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = 0.5 / (sqrt(0.5) + 1.0);
}
return tmp;
}
function code(x) tmp = 0.0 if (hypot(1.0, x) <= 2.0) tmp = Float64(Float64(fma(fma(fma(-0.056243896484375, Float64(x * x), 0.0673828125), Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = Float64(0.5 / Float64(sqrt(0.5) + 1.0)); end return tmp end
code[x_] := If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 2.0], N[(N[(N[(N[(N[(-0.056243896484375 * N[(x * x), $MachinePrecision] + 0.0673828125), $MachinePrecision] * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(0.5 / N[(N[Sqrt[0.5], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 2:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(-0.056243896484375, x \cdot x, 0.0673828125\right), x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{0.5}{\sqrt{0.5} + 1}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 2Initial program 54.9%
Applied rewrites54.9%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
Applied rewrites99.8%
if 2 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.5%
Applied rewrites100.0%
Taylor expanded in x around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6498.7
Applied rewrites98.7%
(FPCore (x) :precision binary64 (if (<= (hypot 1.0 x) 2.0) (* (* (fma (fma 0.0673828125 (* x x) -0.0859375) (* x x) 0.125) x) x) (/ 0.5 (+ (sqrt 0.5) 1.0))))
double code(double x) {
double tmp;
if (hypot(1.0, x) <= 2.0) {
tmp = (fma(fma(0.0673828125, (x * x), -0.0859375), (x * x), 0.125) * x) * x;
} else {
tmp = 0.5 / (sqrt(0.5) + 1.0);
}
return tmp;
}
function code(x) tmp = 0.0 if (hypot(1.0, x) <= 2.0) tmp = Float64(Float64(fma(fma(0.0673828125, Float64(x * x), -0.0859375), Float64(x * x), 0.125) * x) * x); else tmp = Float64(0.5 / Float64(sqrt(0.5) + 1.0)); end return tmp end
code[x_] := If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 2.0], N[(N[(N[(N[(0.0673828125 * N[(x * x), $MachinePrecision] + -0.0859375), $MachinePrecision] * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(0.5 / N[(N[Sqrt[0.5], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 2:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(0.0673828125, x \cdot x, -0.0859375\right), x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{0.5}{\sqrt{0.5} + 1}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 2Initial program 54.9%
Applied rewrites54.9%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6499.7
Applied rewrites99.7%
if 2 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.5%
Applied rewrites100.0%
Taylor expanded in x around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6498.7
Applied rewrites98.7%
(FPCore (x) :precision binary64 (if (<= (hypot 1.0 x) 2.0) (* (* (fma -0.0859375 (* x x) 0.125) x) x) (/ 0.5 (+ (sqrt 0.5) 1.0))))
double code(double x) {
double tmp;
if (hypot(1.0, x) <= 2.0) {
tmp = (fma(-0.0859375, (x * x), 0.125) * x) * x;
} else {
tmp = 0.5 / (sqrt(0.5) + 1.0);
}
return tmp;
}
function code(x) tmp = 0.0 if (hypot(1.0, x) <= 2.0) tmp = Float64(Float64(fma(-0.0859375, Float64(x * x), 0.125) * x) * x); else tmp = Float64(0.5 / Float64(sqrt(0.5) + 1.0)); end return tmp end
code[x_] := If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 2.0], N[(N[(N[(-0.0859375 * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(0.5 / N[(N[Sqrt[0.5], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 2:\\
\;\;\;\;\left(\mathsf{fma}\left(-0.0859375, x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{0.5}{\sqrt{0.5} + 1}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 2Initial program 54.9%
Applied rewrites54.9%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6499.5
Applied rewrites99.5%
if 2 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.5%
Applied rewrites100.0%
Taylor expanded in x around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6498.7
Applied rewrites98.7%
(FPCore (x) :precision binary64 (if (<= (hypot 1.0 x) 2.0) (* (* (fma -0.0859375 (* x x) 0.125) x) x) (- 1.0 (sqrt 0.5))))
double code(double x) {
double tmp;
if (hypot(1.0, x) <= 2.0) {
tmp = (fma(-0.0859375, (x * x), 0.125) * x) * x;
} else {
tmp = 1.0 - sqrt(0.5);
}
return tmp;
}
function code(x) tmp = 0.0 if (hypot(1.0, x) <= 2.0) tmp = Float64(Float64(fma(-0.0859375, Float64(x * x), 0.125) * x) * x); else tmp = Float64(1.0 - sqrt(0.5)); end return tmp end
code[x_] := If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 2.0], N[(N[(N[(-0.0859375 * N[(x * x), $MachinePrecision] + 0.125), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision], N[(1.0 - N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 2:\\
\;\;\;\;\left(\mathsf{fma}\left(-0.0859375, x \cdot x, 0.125\right) \cdot x\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;1 - \sqrt{0.5}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 2Initial program 54.9%
Applied rewrites54.9%
Taylor expanded in x around 0
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6499.5
Applied rewrites99.5%
if 2 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.5%
Taylor expanded in x around inf
Applied rewrites97.2%
(FPCore (x) :precision binary64 (if (<= (hypot 1.0 x) 2.0) (* 0.125 (* x x)) (- 1.0 (sqrt 0.5))))
double code(double x) {
double tmp;
if (hypot(1.0, x) <= 2.0) {
tmp = 0.125 * (x * x);
} else {
tmp = 1.0 - sqrt(0.5);
}
return tmp;
}
public static double code(double x) {
double tmp;
if (Math.hypot(1.0, x) <= 2.0) {
tmp = 0.125 * (x * x);
} else {
tmp = 1.0 - Math.sqrt(0.5);
}
return tmp;
}
def code(x): tmp = 0 if math.hypot(1.0, x) <= 2.0: tmp = 0.125 * (x * x) else: tmp = 1.0 - math.sqrt(0.5) return tmp
function code(x) tmp = 0.0 if (hypot(1.0, x) <= 2.0) tmp = Float64(0.125 * Float64(x * x)); else tmp = Float64(1.0 - sqrt(0.5)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (hypot(1.0, x) <= 2.0) tmp = 0.125 * (x * x); else tmp = 1.0 - sqrt(0.5); end tmp_2 = tmp; end
code[x_] := If[LessEqual[N[Sqrt[1.0 ^ 2 + x ^ 2], $MachinePrecision], 2.0], N[(0.125 * N[(x * x), $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\mathsf{hypot}\left(1, x\right) \leq 2:\\
\;\;\;\;0.125 \cdot \left(x \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;1 - \sqrt{0.5}\\
\end{array}
\end{array}
if (hypot.f64 #s(literal 1 binary64) x) < 2Initial program 54.9%
Applied rewrites54.9%
Taylor expanded in x around 0
lower-*.f64N/A
unpow2N/A
lower-*.f6498.6
Applied rewrites98.6%
if 2 < (hypot.f64 #s(literal 1 binary64) x) Initial program 98.5%
Taylor expanded in x around inf
Applied rewrites97.2%
(FPCore (x) :precision binary64 (* 0.125 (* x x)))
double code(double x) {
return 0.125 * (x * x);
}
real(8) function code(x)
real(8), intent (in) :: x
code = 0.125d0 * (x * x)
end function
public static double code(double x) {
return 0.125 * (x * x);
}
def code(x): return 0.125 * (x * x)
function code(x) return Float64(0.125 * Float64(x * x)) end
function tmp = code(x) tmp = 0.125 * (x * x); end
code[x_] := N[(0.125 * N[(x * x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.125 \cdot \left(x \cdot x\right)
\end{array}
Initial program 73.6%
Applied rewrites74.3%
Taylor expanded in x around 0
lower-*.f64N/A
unpow2N/A
lower-*.f6457.9
Applied rewrites57.9%
herbie shell --seed 2024331
(FPCore (x)
:name "Given's Rotation SVD example, simplified"
:precision binary64
(- 1.0 (sqrt (* 0.5 (+ 1.0 (/ 1.0 (hypot 1.0 x)))))))