
(FPCore (x y) :precision binary64 (/ (* (- x y) (+ x y)) (+ (* x x) (* y y))))
double code(double x, double y) {
return ((x - y) * (x + y)) / ((x * x) + (y * y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x - y) * (x + y)) / ((x * x) + (y * y))
end function
public static double code(double x, double y) {
return ((x - y) * (x + y)) / ((x * x) + (y * y));
}
def code(x, y): return ((x - y) * (x + y)) / ((x * x) + (y * y))
function code(x, y) return Float64(Float64(Float64(x - y) * Float64(x + y)) / Float64(Float64(x * x) + Float64(y * y))) end
function tmp = code(x, y) tmp = ((x - y) * (x + y)) / ((x * x) + (y * y)); end
code[x_, y_] := N[(N[(N[(x - y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] / N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x - y\right) \cdot \left(x + y\right)}{x \cdot x + y \cdot y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (/ (* (- x y) (+ x y)) (+ (* x x) (* y y))))
double code(double x, double y) {
return ((x - y) * (x + y)) / ((x * x) + (y * y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x - y) * (x + y)) / ((x * x) + (y * y))
end function
public static double code(double x, double y) {
return ((x - y) * (x + y)) / ((x * x) + (y * y));
}
def code(x, y): return ((x - y) * (x + y)) / ((x * x) + (y * y))
function code(x, y) return Float64(Float64(Float64(x - y) * Float64(x + y)) / Float64(Float64(x * x) + Float64(y * y))) end
function tmp = code(x, y) tmp = ((x - y) * (x + y)) / ((x * x) + (y * y)); end
code[x_, y_] := N[(N[(N[(x - y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] / N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x - y\right) \cdot \left(x + y\right)}{x \cdot x + y \cdot y}
\end{array}
y_m = (fabs.f64 y) (FPCore (x y_m) :precision binary64 (/ (* (- x y_m) (/ (+ x y_m) (hypot y_m x))) (hypot y_m x)))
y_m = fabs(y);
double code(double x, double y_m) {
return ((x - y_m) * ((x + y_m) / hypot(y_m, x))) / hypot(y_m, x);
}
y_m = Math.abs(y);
public static double code(double x, double y_m) {
return ((x - y_m) * ((x + y_m) / Math.hypot(y_m, x))) / Math.hypot(y_m, x);
}
y_m = math.fabs(y) def code(x, y_m): return ((x - y_m) * ((x + y_m) / math.hypot(y_m, x))) / math.hypot(y_m, x)
y_m = abs(y) function code(x, y_m) return Float64(Float64(Float64(x - y_m) * Float64(Float64(x + y_m) / hypot(y_m, x))) / hypot(y_m, x)) end
y_m = abs(y); function tmp = code(x, y_m) tmp = ((x - y_m) * ((x + y_m) / hypot(y_m, x))) / hypot(y_m, x); end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := N[(N[(N[(x - y$95$m), $MachinePrecision] * N[(N[(x + y$95$m), $MachinePrecision] / N[Sqrt[y$95$m ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[y$95$m ^ 2 + x ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
y_m = \left|y\right|
\\
\frac{\left(x - y\_m\right) \cdot \frac{x + y\_m}{\mathsf{hypot}\left(y\_m, x\right)}}{\mathsf{hypot}\left(y\_m, x\right)}
\end{array}
Initial program 62.7%
fma-def62.7%
add-sqr-sqrt62.7%
times-frac63.4%
fma-def63.4%
hypot-def63.4%
fma-def63.4%
hypot-def99.9%
Applied egg-rr99.9%
associate-*l/99.9%
+-commutative99.9%
hypot-udef63.4%
+-commutative63.4%
hypot-def99.9%
hypot-udef63.4%
+-commutative63.4%
hypot-def99.9%
Applied egg-rr99.9%
Final simplification99.9%
y_m = (fabs.f64 y) (FPCore (x y_m) :precision binary64 (* (/ (- x y_m) (hypot x y_m)) (/ (+ x y_m) (hypot x y_m))))
y_m = fabs(y);
double code(double x, double y_m) {
return ((x - y_m) / hypot(x, y_m)) * ((x + y_m) / hypot(x, y_m));
}
y_m = Math.abs(y);
public static double code(double x, double y_m) {
return ((x - y_m) / Math.hypot(x, y_m)) * ((x + y_m) / Math.hypot(x, y_m));
}
y_m = math.fabs(y) def code(x, y_m): return ((x - y_m) / math.hypot(x, y_m)) * ((x + y_m) / math.hypot(x, y_m))
y_m = abs(y) function code(x, y_m) return Float64(Float64(Float64(x - y_m) / hypot(x, y_m)) * Float64(Float64(x + y_m) / hypot(x, y_m))) end
y_m = abs(y); function tmp = code(x, y_m) tmp = ((x - y_m) / hypot(x, y_m)) * ((x + y_m) / hypot(x, y_m)); end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := N[(N[(N[(x - y$95$m), $MachinePrecision] / N[Sqrt[x ^ 2 + y$95$m ^ 2], $MachinePrecision]), $MachinePrecision] * N[(N[(x + y$95$m), $MachinePrecision] / N[Sqrt[x ^ 2 + y$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
y_m = \left|y\right|
\\
\frac{x - y\_m}{\mathsf{hypot}\left(x, y\_m\right)} \cdot \frac{x + y\_m}{\mathsf{hypot}\left(x, y\_m\right)}
\end{array}
Initial program 62.7%
fma-def62.7%
add-sqr-sqrt62.7%
times-frac63.4%
fma-def63.4%
hypot-def63.4%
fma-def63.4%
hypot-def99.9%
Applied egg-rr99.9%
Final simplification99.9%
y_m = (fabs.f64 y)
(FPCore (x y_m)
:precision binary64
(if (<= y_m 1.85e-192)
(fma (/ (/ y_m x) (/ x y_m)) -2.0 1.0)
(if (<= y_m 1.62e-167)
(* (/ (- x y_m) (hypot x y_m)) (+ (/ x y_m) 1.0))
(if (<= y_m 4e-10)
(/ (* (- x y_m) (+ x y_m)) (+ (* x x) (* y_m y_m)))
-1.0))))y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if (y_m <= 1.85e-192) {
tmp = fma(((y_m / x) / (x / y_m)), -2.0, 1.0);
} else if (y_m <= 1.62e-167) {
tmp = ((x - y_m) / hypot(x, y_m)) * ((x / y_m) + 1.0);
} else if (y_m <= 4e-10) {
tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m));
} else {
tmp = -1.0;
}
return tmp;
}
y_m = abs(y) function code(x, y_m) tmp = 0.0 if (y_m <= 1.85e-192) tmp = fma(Float64(Float64(y_m / x) / Float64(x / y_m)), -2.0, 1.0); elseif (y_m <= 1.62e-167) tmp = Float64(Float64(Float64(x - y_m) / hypot(x, y_m)) * Float64(Float64(x / y_m) + 1.0)); elseif (y_m <= 4e-10) tmp = Float64(Float64(Float64(x - y_m) * Float64(x + y_m)) / Float64(Float64(x * x) + Float64(y_m * y_m))); else tmp = -1.0; end return tmp end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[LessEqual[y$95$m, 1.85e-192], N[(N[(N[(y$95$m / x), $MachinePrecision] / N[(x / y$95$m), $MachinePrecision]), $MachinePrecision] * -2.0 + 1.0), $MachinePrecision], If[LessEqual[y$95$m, 1.62e-167], N[(N[(N[(x - y$95$m), $MachinePrecision] / N[Sqrt[x ^ 2 + y$95$m ^ 2], $MachinePrecision]), $MachinePrecision] * N[(N[(x / y$95$m), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$95$m, 4e-10], N[(N[(N[(x - y$95$m), $MachinePrecision] * N[(x + y$95$m), $MachinePrecision]), $MachinePrecision] / N[(N[(x * x), $MachinePrecision] + N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 1.85 \cdot 10^{-192}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{y\_m}{x}}{\frac{x}{y\_m}}, -2, 1\right)\\
\mathbf{elif}\;y\_m \leq 1.62 \cdot 10^{-167}:\\
\;\;\;\;\frac{x - y\_m}{\mathsf{hypot}\left(x, y\_m\right)} \cdot \left(\frac{x}{y\_m} + 1\right)\\
\mathbf{elif}\;y\_m \leq 4 \cdot 10^{-10}:\\
\;\;\;\;\frac{\left(x - y\_m\right) \cdot \left(x + y\_m\right)}{x \cdot x + y\_m \cdot y\_m}\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if y < 1.85e-192Initial program 56.2%
fma-def56.2%
add-sqr-sqrt56.2%
times-frac57.1%
fma-def57.1%
hypot-def57.1%
fma-def57.1%
hypot-def100.0%
Applied egg-rr100.0%
associate-*l/100.0%
+-commutative100.0%
hypot-udef57.1%
+-commutative57.1%
hypot-def100.0%
hypot-udef57.1%
+-commutative57.1%
hypot-def100.0%
Applied egg-rr100.0%
Taylor expanded in y around 0 25.5%
+-commutative25.5%
*-commutative25.5%
fma-def25.5%
unpow225.5%
unpow225.5%
times-frac37.3%
unpow237.3%
Simplified37.3%
unpow237.3%
clear-num37.3%
un-div-inv37.3%
Applied egg-rr37.3%
if 1.85e-192 < y < 1.62e-167Initial program 30.0%
fma-def30.0%
add-sqr-sqrt30.0%
times-frac32.2%
fma-def32.2%
hypot-def32.2%
fma-def32.2%
hypot-def99.7%
Applied egg-rr99.7%
Taylor expanded in x around 0 71.4%
if 1.62e-167 < y < 4.00000000000000015e-10Initial program 98.8%
if 4.00000000000000015e-10 < y Initial program 100.0%
+-commutative100.0%
associate-*r/99.2%
+-commutative99.2%
fma-def99.2%
Simplified99.2%
Taylor expanded in x around 0 100.0%
Final simplification49.5%
y_m = (fabs.f64 y)
(FPCore (x y_m)
:precision binary64
(if (<= y_m 6.8e-188)
(- (+ 1.0 (* (/ y_m x) (- 1.0 (/ y_m x)))) (/ y_m x))
(if (<= y_m 2.8e-165)
(fma 2.0 (/ (/ x y_m) (/ y_m x)) -1.0)
(if (<= y_m 1e-5)
(/ (* (- x y_m) (+ x y_m)) (+ (* x x) (* y_m y_m)))
-1.0))))y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if (y_m <= 6.8e-188) {
tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x);
} else if (y_m <= 2.8e-165) {
tmp = fma(2.0, ((x / y_m) / (y_m / x)), -1.0);
} else if (y_m <= 1e-5) {
tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m));
} else {
tmp = -1.0;
}
return tmp;
}
y_m = abs(y) function code(x, y_m) tmp = 0.0 if (y_m <= 6.8e-188) tmp = Float64(Float64(1.0 + Float64(Float64(y_m / x) * Float64(1.0 - Float64(y_m / x)))) - Float64(y_m / x)); elseif (y_m <= 2.8e-165) tmp = fma(2.0, Float64(Float64(x / y_m) / Float64(y_m / x)), -1.0); elseif (y_m <= 1e-5) tmp = Float64(Float64(Float64(x - y_m) * Float64(x + y_m)) / Float64(Float64(x * x) + Float64(y_m * y_m))); else tmp = -1.0; end return tmp end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[LessEqual[y$95$m, 6.8e-188], N[(N[(1.0 + N[(N[(y$95$m / x), $MachinePrecision] * N[(1.0 - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$95$m, 2.8e-165], N[(2.0 * N[(N[(x / y$95$m), $MachinePrecision] / N[(y$95$m / x), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], If[LessEqual[y$95$m, 1e-5], N[(N[(N[(x - y$95$m), $MachinePrecision] * N[(x + y$95$m), $MachinePrecision]), $MachinePrecision] / N[(N[(x * x), $MachinePrecision] + N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 6.8 \cdot 10^{-188}:\\
\;\;\;\;\left(1 + \frac{y\_m}{x} \cdot \left(1 - \frac{y\_m}{x}\right)\right) - \frac{y\_m}{x}\\
\mathbf{elif}\;y\_m \leq 2.8 \cdot 10^{-165}:\\
\;\;\;\;\mathsf{fma}\left(2, \frac{\frac{x}{y\_m}}{\frac{y\_m}{x}}, -1\right)\\
\mathbf{elif}\;y\_m \leq 10^{-5}:\\
\;\;\;\;\frac{\left(x - y\_m\right) \cdot \left(x + y\_m\right)}{x \cdot x + y\_m \cdot y\_m}\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if y < 6.80000000000000055e-188Initial program 56.1%
fma-def56.1%
add-sqr-sqrt56.1%
times-frac57.1%
fma-def57.1%
hypot-def57.1%
fma-def57.1%
hypot-def100.0%
Applied egg-rr100.0%
Taylor expanded in x around inf 37.6%
mul-1-neg37.6%
unsub-neg37.6%
Simplified37.6%
Taylor expanded in x around inf 37.1%
+-commutative37.1%
Simplified37.1%
distribute-rgt-in36.3%
*-un-lft-identity36.3%
associate-+r-36.3%
Applied egg-rr36.3%
if 6.80000000000000055e-188 < y < 2.7999999999999999e-165Initial program 25.0%
fma-def25.0%
add-sqr-sqrt25.0%
times-frac27.3%
fma-def27.3%
hypot-def27.3%
fma-def27.3%
hypot-def99.6%
Applied egg-rr99.6%
associate-*l/99.8%
+-commutative99.8%
hypot-udef27.3%
+-commutative27.3%
hypot-def99.8%
hypot-udef27.3%
+-commutative27.3%
hypot-def99.8%
Applied egg-rr99.8%
Taylor expanded in x around 0 0.8%
fma-neg0.8%
unpow20.8%
unpow20.8%
times-frac76.2%
unpow276.2%
metadata-eval76.2%
Simplified76.2%
unpow276.2%
clear-num76.2%
un-div-inv76.2%
Applied egg-rr76.2%
if 2.7999999999999999e-165 < y < 1.00000000000000008e-5Initial program 98.8%
if 1.00000000000000008e-5 < y Initial program 100.0%
+-commutative100.0%
associate-*r/99.2%
+-commutative99.2%
fma-def99.2%
Simplified99.2%
Taylor expanded in x around 0 100.0%
Final simplification48.5%
y_m = (fabs.f64 y)
(FPCore (x y_m)
:precision binary64
(if (<= y_m 7.2e-188)
(fma (/ (/ y_m x) (/ x y_m)) -2.0 1.0)
(if (<= y_m 1.5e-167)
(fma 2.0 (/ (/ x y_m) (/ y_m x)) -1.0)
(if (<= y_m 2e-6)
(/ (* (- x y_m) (+ x y_m)) (+ (* x x) (* y_m y_m)))
-1.0))))y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if (y_m <= 7.2e-188) {
tmp = fma(((y_m / x) / (x / y_m)), -2.0, 1.0);
} else if (y_m <= 1.5e-167) {
tmp = fma(2.0, ((x / y_m) / (y_m / x)), -1.0);
} else if (y_m <= 2e-6) {
tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m));
} else {
tmp = -1.0;
}
return tmp;
}
y_m = abs(y) function code(x, y_m) tmp = 0.0 if (y_m <= 7.2e-188) tmp = fma(Float64(Float64(y_m / x) / Float64(x / y_m)), -2.0, 1.0); elseif (y_m <= 1.5e-167) tmp = fma(2.0, Float64(Float64(x / y_m) / Float64(y_m / x)), -1.0); elseif (y_m <= 2e-6) tmp = Float64(Float64(Float64(x - y_m) * Float64(x + y_m)) / Float64(Float64(x * x) + Float64(y_m * y_m))); else tmp = -1.0; end return tmp end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[LessEqual[y$95$m, 7.2e-188], N[(N[(N[(y$95$m / x), $MachinePrecision] / N[(x / y$95$m), $MachinePrecision]), $MachinePrecision] * -2.0 + 1.0), $MachinePrecision], If[LessEqual[y$95$m, 1.5e-167], N[(2.0 * N[(N[(x / y$95$m), $MachinePrecision] / N[(y$95$m / x), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], If[LessEqual[y$95$m, 2e-6], N[(N[(N[(x - y$95$m), $MachinePrecision] * N[(x + y$95$m), $MachinePrecision]), $MachinePrecision] / N[(N[(x * x), $MachinePrecision] + N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 7.2 \cdot 10^{-188}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{y\_m}{x}}{\frac{x}{y\_m}}, -2, 1\right)\\
\mathbf{elif}\;y\_m \leq 1.5 \cdot 10^{-167}:\\
\;\;\;\;\mathsf{fma}\left(2, \frac{\frac{x}{y\_m}}{\frac{y\_m}{x}}, -1\right)\\
\mathbf{elif}\;y\_m \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\frac{\left(x - y\_m\right) \cdot \left(x + y\_m\right)}{x \cdot x + y\_m \cdot y\_m}\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if y < 7.1999999999999994e-188Initial program 56.1%
fma-def56.1%
add-sqr-sqrt56.1%
times-frac57.1%
fma-def57.1%
hypot-def57.1%
fma-def57.1%
hypot-def100.0%
Applied egg-rr100.0%
associate-*l/100.0%
+-commutative100.0%
hypot-udef57.1%
+-commutative57.1%
hypot-def100.0%
hypot-udef57.1%
+-commutative57.1%
hypot-def100.0%
Applied egg-rr100.0%
Taylor expanded in y around 0 25.7%
+-commutative25.7%
*-commutative25.7%
fma-def25.7%
unpow225.7%
unpow225.7%
times-frac37.5%
unpow237.5%
Simplified37.5%
unpow237.5%
clear-num37.5%
un-div-inv37.5%
Applied egg-rr37.5%
if 7.1999999999999994e-188 < y < 1.4999999999999999e-167Initial program 25.0%
fma-def25.0%
add-sqr-sqrt25.0%
times-frac27.3%
fma-def27.3%
hypot-def27.3%
fma-def27.3%
hypot-def99.6%
Applied egg-rr99.6%
associate-*l/99.8%
+-commutative99.8%
hypot-udef27.3%
+-commutative27.3%
hypot-def99.8%
hypot-udef27.3%
+-commutative27.3%
hypot-def99.8%
Applied egg-rr99.8%
Taylor expanded in x around 0 0.8%
fma-neg0.8%
unpow20.8%
unpow20.8%
times-frac76.2%
unpow276.2%
metadata-eval76.2%
Simplified76.2%
unpow276.2%
clear-num76.2%
un-div-inv76.2%
Applied egg-rr76.2%
if 1.4999999999999999e-167 < y < 1.99999999999999991e-6Initial program 98.8%
if 1.99999999999999991e-6 < y Initial program 100.0%
+-commutative100.0%
associate-*r/99.2%
+-commutative99.2%
fma-def99.2%
Simplified99.2%
Taylor expanded in x around 0 100.0%
Final simplification49.5%
y_m = (fabs.f64 y) (FPCore (x y_m) :precision binary64 (if (or (<= y_m 7.2e-188) (and (not (<= y_m 5.7e-173)) (<= y_m 1.92e-143))) (- (+ 1.0 (* (/ y_m x) (- 1.0 (/ y_m x)))) (/ y_m x)) (* (+ (/ x y_m) 1.0) (+ (/ x y_m) -1.0))))
y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if ((y_m <= 7.2e-188) || (!(y_m <= 5.7e-173) && (y_m <= 1.92e-143))) {
tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x);
} else {
tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0);
}
return tmp;
}
y_m = abs(y)
real(8) function code(x, y_m)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8) :: tmp
if ((y_m <= 7.2d-188) .or. (.not. (y_m <= 5.7d-173)) .and. (y_m <= 1.92d-143)) then
tmp = (1.0d0 + ((y_m / x) * (1.0d0 - (y_m / x)))) - (y_m / x)
else
tmp = ((x / y_m) + 1.0d0) * ((x / y_m) + (-1.0d0))
end if
code = tmp
end function
y_m = Math.abs(y);
public static double code(double x, double y_m) {
double tmp;
if ((y_m <= 7.2e-188) || (!(y_m <= 5.7e-173) && (y_m <= 1.92e-143))) {
tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x);
} else {
tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0);
}
return tmp;
}
y_m = math.fabs(y) def code(x, y_m): tmp = 0 if (y_m <= 7.2e-188) or (not (y_m <= 5.7e-173) and (y_m <= 1.92e-143)): tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x) else: tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0) return tmp
y_m = abs(y) function code(x, y_m) tmp = 0.0 if ((y_m <= 7.2e-188) || (!(y_m <= 5.7e-173) && (y_m <= 1.92e-143))) tmp = Float64(Float64(1.0 + Float64(Float64(y_m / x) * Float64(1.0 - Float64(y_m / x)))) - Float64(y_m / x)); else tmp = Float64(Float64(Float64(x / y_m) + 1.0) * Float64(Float64(x / y_m) + -1.0)); end return tmp end
y_m = abs(y); function tmp_2 = code(x, y_m) tmp = 0.0; if ((y_m <= 7.2e-188) || (~((y_m <= 5.7e-173)) && (y_m <= 1.92e-143))) tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x); else tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0); end tmp_2 = tmp; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[Or[LessEqual[y$95$m, 7.2e-188], And[N[Not[LessEqual[y$95$m, 5.7e-173]], $MachinePrecision], LessEqual[y$95$m, 1.92e-143]]], N[(N[(1.0 + N[(N[(y$95$m / x), $MachinePrecision] * N[(1.0 - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x / y$95$m), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(x / y$95$m), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 7.2 \cdot 10^{-188} \lor \neg \left(y\_m \leq 5.7 \cdot 10^{-173}\right) \land y\_m \leq 1.92 \cdot 10^{-143}:\\
\;\;\;\;\left(1 + \frac{y\_m}{x} \cdot \left(1 - \frac{y\_m}{x}\right)\right) - \frac{y\_m}{x}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{x}{y\_m} + 1\right) \cdot \left(\frac{x}{y\_m} + -1\right)\\
\end{array}
\end{array}
if y < 7.1999999999999994e-188 or 5.7000000000000001e-173 < y < 1.91999999999999995e-143Initial program 56.9%
fma-def56.9%
add-sqr-sqrt56.9%
times-frac57.7%
fma-def57.7%
hypot-def57.8%
fma-def57.8%
hypot-def100.0%
Applied egg-rr100.0%
Taylor expanded in x around inf 38.6%
mul-1-neg38.6%
unsub-neg38.6%
Simplified38.6%
Taylor expanded in x around inf 38.1%
+-commutative38.1%
Simplified38.1%
distribute-rgt-in37.3%
*-un-lft-identity37.3%
associate-+r-37.3%
Applied egg-rr37.3%
if 7.1999999999999994e-188 < y < 5.7000000000000001e-173 or 1.91999999999999995e-143 < y Initial program 89.0%
fma-def89.0%
add-sqr-sqrt88.9%
times-frac89.3%
fma-def89.3%
hypot-def89.3%
fma-def89.3%
hypot-def99.7%
Applied egg-rr99.7%
Taylor expanded in x around 0 72.6%
Taylor expanded in x around 0 72.1%
Final simplification43.6%
y_m = (fabs.f64 y)
(FPCore (x y_m)
:precision binary64
(if (<= y_m 7.2e-188)
(- (+ 1.0 (* (/ y_m x) (- 1.0 (/ y_m x)))) (/ y_m x))
(if (<= y_m 1.48e-170)
(* (+ (/ x y_m) 1.0) (+ (/ x y_m) -1.0))
(if (<= y_m 1e-7)
(/ (* (- x y_m) (+ x y_m)) (+ (* x x) (* y_m y_m)))
-1.0))))y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if (y_m <= 7.2e-188) {
tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x);
} else if (y_m <= 1.48e-170) {
tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0);
} else if (y_m <= 1e-7) {
tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m));
} else {
tmp = -1.0;
}
return tmp;
}
y_m = abs(y)
real(8) function code(x, y_m)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8) :: tmp
if (y_m <= 7.2d-188) then
tmp = (1.0d0 + ((y_m / x) * (1.0d0 - (y_m / x)))) - (y_m / x)
else if (y_m <= 1.48d-170) then
tmp = ((x / y_m) + 1.0d0) * ((x / y_m) + (-1.0d0))
else if (y_m <= 1d-7) then
tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m))
else
tmp = -1.0d0
end if
code = tmp
end function
y_m = Math.abs(y);
public static double code(double x, double y_m) {
double tmp;
if (y_m <= 7.2e-188) {
tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x);
} else if (y_m <= 1.48e-170) {
tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0);
} else if (y_m <= 1e-7) {
tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m));
} else {
tmp = -1.0;
}
return tmp;
}
y_m = math.fabs(y) def code(x, y_m): tmp = 0 if y_m <= 7.2e-188: tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x) elif y_m <= 1.48e-170: tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0) elif y_m <= 1e-7: tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m)) else: tmp = -1.0 return tmp
y_m = abs(y) function code(x, y_m) tmp = 0.0 if (y_m <= 7.2e-188) tmp = Float64(Float64(1.0 + Float64(Float64(y_m / x) * Float64(1.0 - Float64(y_m / x)))) - Float64(y_m / x)); elseif (y_m <= 1.48e-170) tmp = Float64(Float64(Float64(x / y_m) + 1.0) * Float64(Float64(x / y_m) + -1.0)); elseif (y_m <= 1e-7) tmp = Float64(Float64(Float64(x - y_m) * Float64(x + y_m)) / Float64(Float64(x * x) + Float64(y_m * y_m))); else tmp = -1.0; end return tmp end
y_m = abs(y); function tmp_2 = code(x, y_m) tmp = 0.0; if (y_m <= 7.2e-188) tmp = (1.0 + ((y_m / x) * (1.0 - (y_m / x)))) - (y_m / x); elseif (y_m <= 1.48e-170) tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0); elseif (y_m <= 1e-7) tmp = ((x - y_m) * (x + y_m)) / ((x * x) + (y_m * y_m)); else tmp = -1.0; end tmp_2 = tmp; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[LessEqual[y$95$m, 7.2e-188], N[(N[(1.0 + N[(N[(y$95$m / x), $MachinePrecision] * N[(1.0 - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$95$m, 1.48e-170], N[(N[(N[(x / y$95$m), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(x / y$95$m), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$95$m, 1e-7], N[(N[(N[(x - y$95$m), $MachinePrecision] * N[(x + y$95$m), $MachinePrecision]), $MachinePrecision] / N[(N[(x * x), $MachinePrecision] + N[(y$95$m * y$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 7.2 \cdot 10^{-188}:\\
\;\;\;\;\left(1 + \frac{y\_m}{x} \cdot \left(1 - \frac{y\_m}{x}\right)\right) - \frac{y\_m}{x}\\
\mathbf{elif}\;y\_m \leq 1.48 \cdot 10^{-170}:\\
\;\;\;\;\left(\frac{x}{y\_m} + 1\right) \cdot \left(\frac{x}{y\_m} + -1\right)\\
\mathbf{elif}\;y\_m \leq 10^{-7}:\\
\;\;\;\;\frac{\left(x - y\_m\right) \cdot \left(x + y\_m\right)}{x \cdot x + y\_m \cdot y\_m}\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if y < 7.1999999999999994e-188Initial program 56.1%
fma-def56.1%
add-sqr-sqrt56.1%
times-frac57.1%
fma-def57.1%
hypot-def57.1%
fma-def57.1%
hypot-def100.0%
Applied egg-rr100.0%
Taylor expanded in x around inf 37.6%
mul-1-neg37.6%
unsub-neg37.6%
Simplified37.6%
Taylor expanded in x around inf 37.1%
+-commutative37.1%
Simplified37.1%
distribute-rgt-in36.3%
*-un-lft-identity36.3%
associate-+r-36.3%
Applied egg-rr36.3%
if 7.1999999999999994e-188 < y < 1.48000000000000005e-170Initial program 25.0%
fma-def25.0%
add-sqr-sqrt25.0%
times-frac27.3%
fma-def27.3%
hypot-def27.3%
fma-def27.3%
hypot-def99.6%
Applied egg-rr99.6%
Taylor expanded in x around 0 76.0%
Taylor expanded in x around 0 75.6%
if 1.48000000000000005e-170 < y < 9.9999999999999995e-8Initial program 98.8%
if 9.9999999999999995e-8 < y Initial program 100.0%
+-commutative100.0%
associate-*r/99.2%
+-commutative99.2%
fma-def99.2%
Simplified99.2%
Taylor expanded in x around 0 100.0%
Final simplification48.5%
y_m = (fabs.f64 y) (FPCore (x y_m) :precision binary64 (if (or (<= y_m 7.2e-188) (and (not (<= y_m 6.5e-174)) (<= y_m 1.6e-143))) (* (- 1.0 (/ y_m x)) (+ (/ y_m x) 1.0)) -1.0))
y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if ((y_m <= 7.2e-188) || (!(y_m <= 6.5e-174) && (y_m <= 1.6e-143))) {
tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0);
} else {
tmp = -1.0;
}
return tmp;
}
y_m = abs(y)
real(8) function code(x, y_m)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8) :: tmp
if ((y_m <= 7.2d-188) .or. (.not. (y_m <= 6.5d-174)) .and. (y_m <= 1.6d-143)) then
tmp = (1.0d0 - (y_m / x)) * ((y_m / x) + 1.0d0)
else
tmp = -1.0d0
end if
code = tmp
end function
y_m = Math.abs(y);
public static double code(double x, double y_m) {
double tmp;
if ((y_m <= 7.2e-188) || (!(y_m <= 6.5e-174) && (y_m <= 1.6e-143))) {
tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0);
} else {
tmp = -1.0;
}
return tmp;
}
y_m = math.fabs(y) def code(x, y_m): tmp = 0 if (y_m <= 7.2e-188) or (not (y_m <= 6.5e-174) and (y_m <= 1.6e-143)): tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0) else: tmp = -1.0 return tmp
y_m = abs(y) function code(x, y_m) tmp = 0.0 if ((y_m <= 7.2e-188) || (!(y_m <= 6.5e-174) && (y_m <= 1.6e-143))) tmp = Float64(Float64(1.0 - Float64(y_m / x)) * Float64(Float64(y_m / x) + 1.0)); else tmp = -1.0; end return tmp end
y_m = abs(y); function tmp_2 = code(x, y_m) tmp = 0.0; if ((y_m <= 7.2e-188) || (~((y_m <= 6.5e-174)) && (y_m <= 1.6e-143))) tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0); else tmp = -1.0; end tmp_2 = tmp; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[Or[LessEqual[y$95$m, 7.2e-188], And[N[Not[LessEqual[y$95$m, 6.5e-174]], $MachinePrecision], LessEqual[y$95$m, 1.6e-143]]], N[(N[(1.0 - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision] * N[(N[(y$95$m / x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], -1.0]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 7.2 \cdot 10^{-188} \lor \neg \left(y\_m \leq 6.5 \cdot 10^{-174}\right) \land y\_m \leq 1.6 \cdot 10^{-143}:\\
\;\;\;\;\left(1 - \frac{y\_m}{x}\right) \cdot \left(\frac{y\_m}{x} + 1\right)\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if y < 7.1999999999999994e-188 or 6.50000000000000009e-174 < y < 1.5999999999999999e-143Initial program 56.9%
fma-def56.9%
add-sqr-sqrt56.9%
times-frac57.7%
fma-def57.7%
hypot-def57.8%
fma-def57.8%
hypot-def100.0%
Applied egg-rr100.0%
Taylor expanded in x around inf 38.6%
mul-1-neg38.6%
unsub-neg38.6%
Simplified38.6%
Taylor expanded in x around inf 38.1%
+-commutative38.1%
Simplified38.1%
if 7.1999999999999994e-188 < y < 6.50000000000000009e-174 or 1.5999999999999999e-143 < y Initial program 89.0%
+-commutative89.0%
associate-*r/89.0%
+-commutative89.0%
fma-def89.1%
Simplified89.1%
Taylor expanded in x around 0 70.4%
Final simplification43.9%
y_m = (fabs.f64 y) (FPCore (x y_m) :precision binary64 (if (or (<= y_m 7.2e-188) (and (not (<= y_m 7.2e-174)) (<= y_m 1.35e-143))) (* (- 1.0 (/ y_m x)) (+ (/ y_m x) 1.0)) (* (+ (/ x y_m) 1.0) (+ (/ x y_m) -1.0))))
y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if ((y_m <= 7.2e-188) || (!(y_m <= 7.2e-174) && (y_m <= 1.35e-143))) {
tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0);
} else {
tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0);
}
return tmp;
}
y_m = abs(y)
real(8) function code(x, y_m)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8) :: tmp
if ((y_m <= 7.2d-188) .or. (.not. (y_m <= 7.2d-174)) .and. (y_m <= 1.35d-143)) then
tmp = (1.0d0 - (y_m / x)) * ((y_m / x) + 1.0d0)
else
tmp = ((x / y_m) + 1.0d0) * ((x / y_m) + (-1.0d0))
end if
code = tmp
end function
y_m = Math.abs(y);
public static double code(double x, double y_m) {
double tmp;
if ((y_m <= 7.2e-188) || (!(y_m <= 7.2e-174) && (y_m <= 1.35e-143))) {
tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0);
} else {
tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0);
}
return tmp;
}
y_m = math.fabs(y) def code(x, y_m): tmp = 0 if (y_m <= 7.2e-188) or (not (y_m <= 7.2e-174) and (y_m <= 1.35e-143)): tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0) else: tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0) return tmp
y_m = abs(y) function code(x, y_m) tmp = 0.0 if ((y_m <= 7.2e-188) || (!(y_m <= 7.2e-174) && (y_m <= 1.35e-143))) tmp = Float64(Float64(1.0 - Float64(y_m / x)) * Float64(Float64(y_m / x) + 1.0)); else tmp = Float64(Float64(Float64(x / y_m) + 1.0) * Float64(Float64(x / y_m) + -1.0)); end return tmp end
y_m = abs(y); function tmp_2 = code(x, y_m) tmp = 0.0; if ((y_m <= 7.2e-188) || (~((y_m <= 7.2e-174)) && (y_m <= 1.35e-143))) tmp = (1.0 - (y_m / x)) * ((y_m / x) + 1.0); else tmp = ((x / y_m) + 1.0) * ((x / y_m) + -1.0); end tmp_2 = tmp; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[Or[LessEqual[y$95$m, 7.2e-188], And[N[Not[LessEqual[y$95$m, 7.2e-174]], $MachinePrecision], LessEqual[y$95$m, 1.35e-143]]], N[(N[(1.0 - N[(y$95$m / x), $MachinePrecision]), $MachinePrecision] * N[(N[(y$95$m / x), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x / y$95$m), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(x / y$95$m), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 7.2 \cdot 10^{-188} \lor \neg \left(y\_m \leq 7.2 \cdot 10^{-174}\right) \land y\_m \leq 1.35 \cdot 10^{-143}:\\
\;\;\;\;\left(1 - \frac{y\_m}{x}\right) \cdot \left(\frac{y\_m}{x} + 1\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{x}{y\_m} + 1\right) \cdot \left(\frac{x}{y\_m} + -1\right)\\
\end{array}
\end{array}
if y < 7.1999999999999994e-188 or 7.19999999999999997e-174 < y < 1.35000000000000005e-143Initial program 56.9%
fma-def56.9%
add-sqr-sqrt56.9%
times-frac57.7%
fma-def57.7%
hypot-def57.8%
fma-def57.8%
hypot-def100.0%
Applied egg-rr100.0%
Taylor expanded in x around inf 38.6%
mul-1-neg38.6%
unsub-neg38.6%
Simplified38.6%
Taylor expanded in x around inf 38.1%
+-commutative38.1%
Simplified38.1%
if 7.1999999999999994e-188 < y < 7.19999999999999997e-174 or 1.35000000000000005e-143 < y Initial program 89.0%
fma-def89.0%
add-sqr-sqrt88.9%
times-frac89.3%
fma-def89.3%
hypot-def89.3%
fma-def89.3%
hypot-def99.7%
Applied egg-rr99.7%
Taylor expanded in x around 0 72.6%
Taylor expanded in x around 0 72.1%
Final simplification44.2%
y_m = (fabs.f64 y) (FPCore (x y_m) :precision binary64 (if (<= y_m 6.2e-188) 1.0 (if (<= y_m 1e-173) -1.0 (if (<= y_m 2.25e-143) 1.0 -1.0))))
y_m = fabs(y);
double code(double x, double y_m) {
double tmp;
if (y_m <= 6.2e-188) {
tmp = 1.0;
} else if (y_m <= 1e-173) {
tmp = -1.0;
} else if (y_m <= 2.25e-143) {
tmp = 1.0;
} else {
tmp = -1.0;
}
return tmp;
}
y_m = abs(y)
real(8) function code(x, y_m)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
real(8) :: tmp
if (y_m <= 6.2d-188) then
tmp = 1.0d0
else if (y_m <= 1d-173) then
tmp = -1.0d0
else if (y_m <= 2.25d-143) then
tmp = 1.0d0
else
tmp = -1.0d0
end if
code = tmp
end function
y_m = Math.abs(y);
public static double code(double x, double y_m) {
double tmp;
if (y_m <= 6.2e-188) {
tmp = 1.0;
} else if (y_m <= 1e-173) {
tmp = -1.0;
} else if (y_m <= 2.25e-143) {
tmp = 1.0;
} else {
tmp = -1.0;
}
return tmp;
}
y_m = math.fabs(y) def code(x, y_m): tmp = 0 if y_m <= 6.2e-188: tmp = 1.0 elif y_m <= 1e-173: tmp = -1.0 elif y_m <= 2.25e-143: tmp = 1.0 else: tmp = -1.0 return tmp
y_m = abs(y) function code(x, y_m) tmp = 0.0 if (y_m <= 6.2e-188) tmp = 1.0; elseif (y_m <= 1e-173) tmp = -1.0; elseif (y_m <= 2.25e-143) tmp = 1.0; else tmp = -1.0; end return tmp end
y_m = abs(y); function tmp_2 = code(x, y_m) tmp = 0.0; if (y_m <= 6.2e-188) tmp = 1.0; elseif (y_m <= 1e-173) tmp = -1.0; elseif (y_m <= 2.25e-143) tmp = 1.0; else tmp = -1.0; end tmp_2 = tmp; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := If[LessEqual[y$95$m, 6.2e-188], 1.0, If[LessEqual[y$95$m, 1e-173], -1.0, If[LessEqual[y$95$m, 2.25e-143], 1.0, -1.0]]]
\begin{array}{l}
y_m = \left|y\right|
\\
\begin{array}{l}
\mathbf{if}\;y\_m \leq 6.2 \cdot 10^{-188}:\\
\;\;\;\;1\\
\mathbf{elif}\;y\_m \leq 10^{-173}:\\
\;\;\;\;-1\\
\mathbf{elif}\;y\_m \leq 2.25 \cdot 10^{-143}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if y < 6.2000000000000004e-188 or 1e-173 < y < 2.25e-143Initial program 56.9%
+-commutative56.9%
associate-*r/57.5%
+-commutative57.5%
fma-def57.5%
Simplified57.5%
Taylor expanded in x around inf 36.5%
if 6.2000000000000004e-188 < y < 1e-173 or 2.25e-143 < y Initial program 89.0%
+-commutative89.0%
associate-*r/89.0%
+-commutative89.0%
fma-def89.1%
Simplified89.1%
Taylor expanded in x around 0 70.4%
Final simplification42.6%
y_m = (fabs.f64 y) (FPCore (x y_m) :precision binary64 -1.0)
y_m = fabs(y);
double code(double x, double y_m) {
return -1.0;
}
y_m = abs(y)
real(8) function code(x, y_m)
real(8), intent (in) :: x
real(8), intent (in) :: y_m
code = -1.0d0
end function
y_m = Math.abs(y);
public static double code(double x, double y_m) {
return -1.0;
}
y_m = math.fabs(y) def code(x, y_m): return -1.0
y_m = abs(y) function code(x, y_m) return -1.0 end
y_m = abs(y); function tmp = code(x, y_m) tmp = -1.0; end
y_m = N[Abs[y], $MachinePrecision] code[x_, y$95$m_] := -1.0
\begin{array}{l}
y_m = \left|y\right|
\\
-1
\end{array}
Initial program 62.7%
+-commutative62.7%
associate-*r/63.2%
+-commutative63.2%
fma-def63.2%
Simplified63.2%
Taylor expanded in x around 0 64.6%
Final simplification64.6%
(FPCore (x y)
:precision binary64
(let* ((t_0 (fabs (/ x y))))
(if (and (< 0.5 t_0) (< t_0 2.0))
(/ (* (- x y) (+ x y)) (+ (* x x) (* y y)))
(- 1.0 (/ 2.0 (+ 1.0 (* (/ x y) (/ x y))))))))
double code(double x, double y) {
double t_0 = fabs((x / y));
double tmp;
if ((0.5 < t_0) && (t_0 < 2.0)) {
tmp = ((x - y) * (x + y)) / ((x * x) + (y * y));
} else {
tmp = 1.0 - (2.0 / (1.0 + ((x / y) * (x / y))));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = abs((x / y))
if ((0.5d0 < t_0) .and. (t_0 < 2.0d0)) then
tmp = ((x - y) * (x + y)) / ((x * x) + (y * y))
else
tmp = 1.0d0 - (2.0d0 / (1.0d0 + ((x / y) * (x / y))))
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.abs((x / y));
double tmp;
if ((0.5 < t_0) && (t_0 < 2.0)) {
tmp = ((x - y) * (x + y)) / ((x * x) + (y * y));
} else {
tmp = 1.0 - (2.0 / (1.0 + ((x / y) * (x / y))));
}
return tmp;
}
def code(x, y): t_0 = math.fabs((x / y)) tmp = 0 if (0.5 < t_0) and (t_0 < 2.0): tmp = ((x - y) * (x + y)) / ((x * x) + (y * y)) else: tmp = 1.0 - (2.0 / (1.0 + ((x / y) * (x / y)))) return tmp
function code(x, y) t_0 = abs(Float64(x / y)) tmp = 0.0 if ((0.5 < t_0) && (t_0 < 2.0)) tmp = Float64(Float64(Float64(x - y) * Float64(x + y)) / Float64(Float64(x * x) + Float64(y * y))); else tmp = Float64(1.0 - Float64(2.0 / Float64(1.0 + Float64(Float64(x / y) * Float64(x / y))))); end return tmp end
function tmp_2 = code(x, y) t_0 = abs((x / y)); tmp = 0.0; if ((0.5 < t_0) && (t_0 < 2.0)) tmp = ((x - y) * (x + y)) / ((x * x) + (y * y)); else tmp = 1.0 - (2.0 / (1.0 + ((x / y) * (x / y)))); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[Abs[N[(x / y), $MachinePrecision]], $MachinePrecision]}, If[And[Less[0.5, t$95$0], Less[t$95$0, 2.0]], N[(N[(N[(x - y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] / N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 - N[(2.0 / N[(1.0 + N[(N[(x / y), $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left|\frac{x}{y}\right|\\
\mathbf{if}\;0.5 < t\_0 \land t\_0 < 2:\\
\;\;\;\;\frac{\left(x - y\right) \cdot \left(x + y\right)}{x \cdot x + y \cdot y}\\
\mathbf{else}:\\
\;\;\;\;1 - \frac{2}{1 + \frac{x}{y} \cdot \frac{x}{y}}\\
\end{array}
\end{array}
herbie shell --seed 2024036
(FPCore (x y)
:name "Kahan p9 Example"
:precision binary64
:pre (and (and (< 0.0 x) (< x 1.0)) (< y 1.0))
:herbie-target
(if (and (< 0.5 (fabs (/ x y))) (< (fabs (/ x y)) 2.0)) (/ (* (- x y) (+ x y)) (+ (* x x) (* y y))) (- 1.0 (/ 2.0 (+ 1.0 (* (/ x y) (/ x y))))))
(/ (* (- x y) (+ x y)) (+ (* x x) (* y y))))