
(FPCore (x1 y1 x2 y2) :precision binary64 (* (/ x1 (sqrt (+ (* x1 x1) (* y1 y1)))) (sqrt (+ (* x2 x2) (* y2 y2)))))
double code(double x1, double y1, double x2, double y2) {
return (x1 / sqrt(((x1 * x1) + (y1 * y1)))) * sqrt(((x2 * x2) + (y2 * y2)));
}
real(8) function code(x1, y1, x2, y2)
real(8), intent (in) :: x1
real(8), intent (in) :: y1
real(8), intent (in) :: x2
real(8), intent (in) :: y2
code = (x1 / sqrt(((x1 * x1) + (y1 * y1)))) * sqrt(((x2 * x2) + (y2 * y2)))
end function
public static double code(double x1, double y1, double x2, double y2) {
return (x1 / Math.sqrt(((x1 * x1) + (y1 * y1)))) * Math.sqrt(((x2 * x2) + (y2 * y2)));
}
def code(x1, y1, x2, y2): return (x1 / math.sqrt(((x1 * x1) + (y1 * y1)))) * math.sqrt(((x2 * x2) + (y2 * y2)))
function code(x1, y1, x2, y2) return Float64(Float64(x1 / sqrt(Float64(Float64(x1 * x1) + Float64(y1 * y1)))) * sqrt(Float64(Float64(x2 * x2) + Float64(y2 * y2)))) end
function tmp = code(x1, y1, x2, y2) tmp = (x1 / sqrt(((x1 * x1) + (y1 * y1)))) * sqrt(((x2 * x2) + (y2 * y2))); end
code[x1_, y1_, x2_, y2_] := N[(N[(x1 / N[Sqrt[N[(N[(x1 * x1), $MachinePrecision] + N[(y1 * y1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(x2 * x2), $MachinePrecision] + N[(y2 * y2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\frac{x1}{\sqrt{x1 \cdot x1 + y1 \cdot y1}} \cdot \sqrt{x2 \cdot x2 + y2 \cdot y2}
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x1 y1 x2 y2) :precision binary64 (* (/ x1 (sqrt (+ (* x1 x1) (* y1 y1)))) (sqrt (+ (* x2 x2) (* y2 y2)))))
double code(double x1, double y1, double x2, double y2) {
return (x1 / sqrt(((x1 * x1) + (y1 * y1)))) * sqrt(((x2 * x2) + (y2 * y2)));
}
real(8) function code(x1, y1, x2, y2)
real(8), intent (in) :: x1
real(8), intent (in) :: y1
real(8), intent (in) :: x2
real(8), intent (in) :: y2
code = (x1 / sqrt(((x1 * x1) + (y1 * y1)))) * sqrt(((x2 * x2) + (y2 * y2)))
end function
public static double code(double x1, double y1, double x2, double y2) {
return (x1 / Math.sqrt(((x1 * x1) + (y1 * y1)))) * Math.sqrt(((x2 * x2) + (y2 * y2)));
}
def code(x1, y1, x2, y2): return (x1 / math.sqrt(((x1 * x1) + (y1 * y1)))) * math.sqrt(((x2 * x2) + (y2 * y2)))
function code(x1, y1, x2, y2) return Float64(Float64(x1 / sqrt(Float64(Float64(x1 * x1) + Float64(y1 * y1)))) * sqrt(Float64(Float64(x2 * x2) + Float64(y2 * y2)))) end
function tmp = code(x1, y1, x2, y2) tmp = (x1 / sqrt(((x1 * x1) + (y1 * y1)))) * sqrt(((x2 * x2) + (y2 * y2))); end
code[x1_, y1_, x2_, y2_] := N[(N[(x1 / N[Sqrt[N[(N[(x1 * x1), $MachinePrecision] + N[(y1 * y1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(x2 * x2), $MachinePrecision] + N[(y2 * y2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\frac{x1}{\sqrt{x1 \cdot x1 + y1 \cdot y1}} \cdot \sqrt{x2 \cdot x2 + y2 \cdot y2}
(FPCore (x1 y1 x2 y2) :precision binary64 (* (/ x1 (hypot y1 x1)) (hypot y2 x2)))
double code(double x1, double y1, double x2, double y2) {
return (x1 / hypot(y1, x1)) * hypot(y2, x2);
}
public static double code(double x1, double y1, double x2, double y2) {
return (x1 / Math.hypot(y1, x1)) * Math.hypot(y2, x2);
}
def code(x1, y1, x2, y2): return (x1 / math.hypot(y1, x1)) * math.hypot(y2, x2)
function code(x1, y1, x2, y2) return Float64(Float64(x1 / hypot(y1, x1)) * hypot(y2, x2)) end
function tmp = code(x1, y1, x2, y2) tmp = (x1 / hypot(y1, x1)) * hypot(y2, x2); end
code[x1_, y1_, x2_, y2_] := N[(N[(x1 / N[Sqrt[y1 ^ 2 + x1 ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sqrt[y2 ^ 2 + x2 ^ 2], $MachinePrecision]), $MachinePrecision]
\frac{x1}{\mathsf{hypot}\left(y1, x1\right)} \cdot \mathsf{hypot}\left(y2, x2\right)
Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
(FPCore (x1 y1 x2 y2)
:precision binary64
(let* ((t_0
(/ (fabs x1) (sqrt (+ (* (fabs x1) (fabs x1)) (* y1 y1)))))
(t_1 (* t_0 (sqrt (+ (* x2 x2) (* y2 y2))))))
(*
(copysign 1.0 x1)
(if (<= t_1 5e-162)
(* t_0 (hypot y2 x2))
(if (<= t_1 INFINITY)
(*
(/ (fabs x1) (hypot y1 (fabs x1)))
(sqrt (fma y2 y2 (* x2 x2))))
(* 1.0 (hypot y2 x2)))))))double code(double x1, double y1, double x2, double y2) {
double t_0 = fabs(x1) / sqrt(((fabs(x1) * fabs(x1)) + (y1 * y1)));
double t_1 = t_0 * sqrt(((x2 * x2) + (y2 * y2)));
double tmp;
if (t_1 <= 5e-162) {
tmp = t_0 * hypot(y2, x2);
} else if (t_1 <= ((double) INFINITY)) {
tmp = (fabs(x1) / hypot(y1, fabs(x1))) * sqrt(fma(y2, y2, (x2 * x2)));
} else {
tmp = 1.0 * hypot(y2, x2);
}
return copysign(1.0, x1) * tmp;
}
function code(x1, y1, x2, y2) t_0 = Float64(abs(x1) / sqrt(Float64(Float64(abs(x1) * abs(x1)) + Float64(y1 * y1)))) t_1 = Float64(t_0 * sqrt(Float64(Float64(x2 * x2) + Float64(y2 * y2)))) tmp = 0.0 if (t_1 <= 5e-162) tmp = Float64(t_0 * hypot(y2, x2)); elseif (t_1 <= Inf) tmp = Float64(Float64(abs(x1) / hypot(y1, abs(x1))) * sqrt(fma(y2, y2, Float64(x2 * x2)))); else tmp = Float64(1.0 * hypot(y2, x2)); end return Float64(copysign(1.0, x1) * tmp) end
code[x1_, y1_, x2_, y2_] := Block[{t$95$0 = N[(N[Abs[x1], $MachinePrecision] / N[Sqrt[N[(N[(N[Abs[x1], $MachinePrecision] * N[Abs[x1], $MachinePrecision]), $MachinePrecision] + N[(y1 * y1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[Sqrt[N[(N[(x2 * x2), $MachinePrecision] + N[(y2 * y2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, 5e-162], N[(t$95$0 * N[Sqrt[y2 ^ 2 + x2 ^ 2], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[Abs[x1], $MachinePrecision] / N[Sqrt[y1 ^ 2 + N[Abs[x1], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(y2 * y2 + N[(x2 * x2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 * N[Sqrt[y2 ^ 2 + x2 ^ 2], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \frac{\left|x1\right|}{\sqrt{\left|x1\right| \cdot \left|x1\right| + y1 \cdot y1}}\\
t_1 := t\_0 \cdot \sqrt{x2 \cdot x2 + y2 \cdot y2}\\
\mathsf{copysign}\left(1, x1\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_1 \leq 5 \cdot 10^{-162}:\\
\;\;\;\;t\_0 \cdot \mathsf{hypot}\left(y2, x2\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{\left|x1\right|}{\mathsf{hypot}\left(y1, \left|x1\right|\right)} \cdot \sqrt{\mathsf{fma}\left(y2, y2, x2 \cdot x2\right)}\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \mathsf{hypot}\left(y2, x2\right)\\
\end{array}
\end{array}
if (*.f64 (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) (sqrt.f64 (+.f64 (*.f64 x2 x2) (*.f64 y2 y2)))) < 5.0000000000000001e-162Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
sqr-abs-revN/A
sqr-neg-revN/A
fp-cancel-sign-sub-invN/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
distribute-rgt-neg-outN/A
sqr-neg-revN/A
sqr-neg-revN/A
sqr-abs-revN/A
Applied rewrites78.1%
if 5.0000000000000001e-162 < (*.f64 (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) (sqrt.f64 (+.f64 (*.f64 x2 x2) (*.f64 y2 y2)))) < +inf.0Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f6483.4%
Applied rewrites83.4%
if +inf.0 < (*.f64 (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) (sqrt.f64 (+.f64 (*.f64 x2 x2) (*.f64 y2 y2)))) Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
Taylor expanded in x1 around inf
Applied rewrites28.2%
(FPCore (x1 y1 x2 y2)
:precision binary64
(*
(copysign 1.0 x1)
(if (<=
(/
(fabs x1)
(sqrt (+ (* (fabs x1) (fabs x1)) (* (fabs y1) (fabs y1)))))
0.1)
(* (/ (fabs x1) (fabs y1)) (hypot y2 x2))
(* 1.0 (hypot y2 x2)))))double code(double x1, double y1, double x2, double y2) {
double tmp;
if ((fabs(x1) / sqrt(((fabs(x1) * fabs(x1)) + (fabs(y1) * fabs(y1))))) <= 0.1) {
tmp = (fabs(x1) / fabs(y1)) * hypot(y2, x2);
} else {
tmp = 1.0 * hypot(y2, x2);
}
return copysign(1.0, x1) * tmp;
}
public static double code(double x1, double y1, double x2, double y2) {
double tmp;
if ((Math.abs(x1) / Math.sqrt(((Math.abs(x1) * Math.abs(x1)) + (Math.abs(y1) * Math.abs(y1))))) <= 0.1) {
tmp = (Math.abs(x1) / Math.abs(y1)) * Math.hypot(y2, x2);
} else {
tmp = 1.0 * Math.hypot(y2, x2);
}
return Math.copySign(1.0, x1) * tmp;
}
def code(x1, y1, x2, y2): tmp = 0 if (math.fabs(x1) / math.sqrt(((math.fabs(x1) * math.fabs(x1)) + (math.fabs(y1) * math.fabs(y1))))) <= 0.1: tmp = (math.fabs(x1) / math.fabs(y1)) * math.hypot(y2, x2) else: tmp = 1.0 * math.hypot(y2, x2) return math.copysign(1.0, x1) * tmp
function code(x1, y1, x2, y2) tmp = 0.0 if (Float64(abs(x1) / sqrt(Float64(Float64(abs(x1) * abs(x1)) + Float64(abs(y1) * abs(y1))))) <= 0.1) tmp = Float64(Float64(abs(x1) / abs(y1)) * hypot(y2, x2)); else tmp = Float64(1.0 * hypot(y2, x2)); end return Float64(copysign(1.0, x1) * tmp) end
function tmp_2 = code(x1, y1, x2, y2) tmp = 0.0; if ((abs(x1) / sqrt(((abs(x1) * abs(x1)) + (abs(y1) * abs(y1))))) <= 0.1) tmp = (abs(x1) / abs(y1)) * hypot(y2, x2); else tmp = 1.0 * hypot(y2, x2); end tmp_2 = (sign(x1) * abs(1.0)) * tmp; end
code[x1_, y1_, x2_, y2_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[Abs[x1], $MachinePrecision] / N[Sqrt[N[(N[(N[Abs[x1], $MachinePrecision] * N[Abs[x1], $MachinePrecision]), $MachinePrecision] + N[(N[Abs[y1], $MachinePrecision] * N[Abs[y1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.1], N[(N[(N[Abs[x1], $MachinePrecision] / N[Abs[y1], $MachinePrecision]), $MachinePrecision] * N[Sqrt[y2 ^ 2 + x2 ^ 2], $MachinePrecision]), $MachinePrecision], N[(1.0 * N[Sqrt[y2 ^ 2 + x2 ^ 2], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, x1\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{\left|x1\right|}{\sqrt{\left|x1\right| \cdot \left|x1\right| + \left|y1\right| \cdot \left|y1\right|}} \leq 0.1:\\
\;\;\;\;\frac{\left|x1\right|}{\left|y1\right|} \cdot \mathsf{hypot}\left(y2, x2\right)\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \mathsf{hypot}\left(y2, x2\right)\\
\end{array}
if (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) < 0.10000000000000001Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
Taylor expanded in y1 around inf
lower-/.f6431.4%
Applied rewrites31.4%
if 0.10000000000000001 < (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
Taylor expanded in x1 around inf
Applied rewrites28.2%
(FPCore (x1 y1 x2 y2)
:precision binary64
(*
(copysign 1.0 x1)
(if (<=
(/
(fabs x1)
(sqrt (+ (* (fabs x1) (fabs x1)) (* (fabs y1) (fabs y1)))))
0.1)
(* (/ (fabs x1) (fabs y1)) (sqrt (+ (* x2 x2) (* y2 y2))))
(* 1.0 (hypot y2 x2)))))double code(double x1, double y1, double x2, double y2) {
double tmp;
if ((fabs(x1) / sqrt(((fabs(x1) * fabs(x1)) + (fabs(y1) * fabs(y1))))) <= 0.1) {
tmp = (fabs(x1) / fabs(y1)) * sqrt(((x2 * x2) + (y2 * y2)));
} else {
tmp = 1.0 * hypot(y2, x2);
}
return copysign(1.0, x1) * tmp;
}
public static double code(double x1, double y1, double x2, double y2) {
double tmp;
if ((Math.abs(x1) / Math.sqrt(((Math.abs(x1) * Math.abs(x1)) + (Math.abs(y1) * Math.abs(y1))))) <= 0.1) {
tmp = (Math.abs(x1) / Math.abs(y1)) * Math.sqrt(((x2 * x2) + (y2 * y2)));
} else {
tmp = 1.0 * Math.hypot(y2, x2);
}
return Math.copySign(1.0, x1) * tmp;
}
def code(x1, y1, x2, y2): tmp = 0 if (math.fabs(x1) / math.sqrt(((math.fabs(x1) * math.fabs(x1)) + (math.fabs(y1) * math.fabs(y1))))) <= 0.1: tmp = (math.fabs(x1) / math.fabs(y1)) * math.sqrt(((x2 * x2) + (y2 * y2))) else: tmp = 1.0 * math.hypot(y2, x2) return math.copysign(1.0, x1) * tmp
function code(x1, y1, x2, y2) tmp = 0.0 if (Float64(abs(x1) / sqrt(Float64(Float64(abs(x1) * abs(x1)) + Float64(abs(y1) * abs(y1))))) <= 0.1) tmp = Float64(Float64(abs(x1) / abs(y1)) * sqrt(Float64(Float64(x2 * x2) + Float64(y2 * y2)))); else tmp = Float64(1.0 * hypot(y2, x2)); end return Float64(copysign(1.0, x1) * tmp) end
function tmp_2 = code(x1, y1, x2, y2) tmp = 0.0; if ((abs(x1) / sqrt(((abs(x1) * abs(x1)) + (abs(y1) * abs(y1))))) <= 0.1) tmp = (abs(x1) / abs(y1)) * sqrt(((x2 * x2) + (y2 * y2))); else tmp = 1.0 * hypot(y2, x2); end tmp_2 = (sign(x1) * abs(1.0)) * tmp; end
code[x1_, y1_, x2_, y2_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[Abs[x1], $MachinePrecision] / N[Sqrt[N[(N[(N[Abs[x1], $MachinePrecision] * N[Abs[x1], $MachinePrecision]), $MachinePrecision] + N[(N[Abs[y1], $MachinePrecision] * N[Abs[y1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.1], N[(N[(N[Abs[x1], $MachinePrecision] / N[Abs[y1], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(x2 * x2), $MachinePrecision] + N[(y2 * y2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 * N[Sqrt[y2 ^ 2 + x2 ^ 2], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, x1\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{\left|x1\right|}{\sqrt{\left|x1\right| \cdot \left|x1\right| + \left|y1\right| \cdot \left|y1\right|}} \leq 0.1:\\
\;\;\;\;\frac{\left|x1\right|}{\left|y1\right|} \cdot \sqrt{x2 \cdot x2 + y2 \cdot y2}\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \mathsf{hypot}\left(y2, x2\right)\\
\end{array}
if (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) < 0.10000000000000001Initial program 66.1%
Taylor expanded in y1 around inf
lower-/.f6428.7%
Applied rewrites28.7%
if 0.10000000000000001 < (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
Taylor expanded in x1 around inf
Applied rewrites28.2%
(FPCore (x1 y1 x2 y2)
:precision binary64
(*
(copysign 1.0 x1)
(if (<=
(/
(fabs x1)
(sqrt (+ (* (fabs x1) (fabs x1)) (* (fabs y1) (fabs y1)))))
0.995)
(* (/ (fabs x1) (fabs y1)) (sqrt (+ (* x2 x2) (* y2 y2))))
(* (sqrt (fma y2 y2 (* x2 x2))) 1.0))))double code(double x1, double y1, double x2, double y2) {
double tmp;
if ((fabs(x1) / sqrt(((fabs(x1) * fabs(x1)) + (fabs(y1) * fabs(y1))))) <= 0.995) {
tmp = (fabs(x1) / fabs(y1)) * sqrt(((x2 * x2) + (y2 * y2)));
} else {
tmp = sqrt(fma(y2, y2, (x2 * x2))) * 1.0;
}
return copysign(1.0, x1) * tmp;
}
function code(x1, y1, x2, y2) tmp = 0.0 if (Float64(abs(x1) / sqrt(Float64(Float64(abs(x1) * abs(x1)) + Float64(abs(y1) * abs(y1))))) <= 0.995) tmp = Float64(Float64(abs(x1) / abs(y1)) * sqrt(Float64(Float64(x2 * x2) + Float64(y2 * y2)))); else tmp = Float64(sqrt(fma(y2, y2, Float64(x2 * x2))) * 1.0); end return Float64(copysign(1.0, x1) * tmp) end
code[x1_, y1_, x2_, y2_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[Abs[x1], $MachinePrecision] / N[Sqrt[N[(N[(N[Abs[x1], $MachinePrecision] * N[Abs[x1], $MachinePrecision]), $MachinePrecision] + N[(N[Abs[y1], $MachinePrecision] * N[Abs[y1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.995], N[(N[(N[Abs[x1], $MachinePrecision] / N[Abs[y1], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(x2 * x2), $MachinePrecision] + N[(y2 * y2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(y2 * y2 + N[(x2 * x2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 1.0), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, x1\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{\left|x1\right|}{\sqrt{\left|x1\right| \cdot \left|x1\right| + \left|y1\right| \cdot \left|y1\right|}} \leq 0.995:\\
\;\;\;\;\frac{\left|x1\right|}{\left|y1\right|} \cdot \sqrt{x2 \cdot x2 + y2 \cdot y2}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(y2, y2, x2 \cdot x2\right)} \cdot 1\\
\end{array}
if (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) < 0.995Initial program 66.1%
Taylor expanded in y1 around inf
lower-/.f6428.7%
Applied rewrites28.7%
if 0.995 < (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
Taylor expanded in x1 around inf
Applied rewrites28.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6428.2%
lift-hypot.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
lift-sqrt.f6428.1%
Applied rewrites28.1%
(FPCore (x1 y1 x2 y2)
:precision binary64
(let* ((t_0 (sqrt (fma y2 y2 (* x2 x2)))))
(*
(copysign 1.0 x1)
(if (<=
(/
(fabs x1)
(sqrt (+ (* (fabs x1) (fabs x1)) (* (fabs y1) (fabs y1)))))
0.995)
(* (/ (fabs x1) (fabs y1)) t_0)
(* t_0 1.0)))))double code(double x1, double y1, double x2, double y2) {
double t_0 = sqrt(fma(y2, y2, (x2 * x2)));
double tmp;
if ((fabs(x1) / sqrt(((fabs(x1) * fabs(x1)) + (fabs(y1) * fabs(y1))))) <= 0.995) {
tmp = (fabs(x1) / fabs(y1)) * t_0;
} else {
tmp = t_0 * 1.0;
}
return copysign(1.0, x1) * tmp;
}
function code(x1, y1, x2, y2) t_0 = sqrt(fma(y2, y2, Float64(x2 * x2))) tmp = 0.0 if (Float64(abs(x1) / sqrt(Float64(Float64(abs(x1) * abs(x1)) + Float64(abs(y1) * abs(y1))))) <= 0.995) tmp = Float64(Float64(abs(x1) / abs(y1)) * t_0); else tmp = Float64(t_0 * 1.0); end return Float64(copysign(1.0, x1) * tmp) end
code[x1_, y1_, x2_, y2_] := Block[{t$95$0 = N[Sqrt[N[(y2 * y2 + N[(x2 * x2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[Abs[x1], $MachinePrecision] / N[Sqrt[N[(N[(N[Abs[x1], $MachinePrecision] * N[Abs[x1], $MachinePrecision]), $MachinePrecision] + N[(N[Abs[y1], $MachinePrecision] * N[Abs[y1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.995], N[(N[(N[Abs[x1], $MachinePrecision] / N[Abs[y1], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision], N[(t$95$0 * 1.0), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \sqrt{\mathsf{fma}\left(y2, y2, x2 \cdot x2\right)}\\
\mathsf{copysign}\left(1, x1\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{\left|x1\right|}{\sqrt{\left|x1\right| \cdot \left|x1\right| + \left|y1\right| \cdot \left|y1\right|}} \leq 0.995:\\
\;\;\;\;\frac{\left|x1\right|}{\left|y1\right|} \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot 1\\
\end{array}
\end{array}
if (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) < 0.995Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f6483.4%
Applied rewrites83.4%
Taylor expanded in y1 around inf
lower-/.f6428.7%
Applied rewrites28.7%
if 0.995 < (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
Taylor expanded in x1 around inf
Applied rewrites28.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6428.2%
lift-hypot.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
lift-sqrt.f6428.1%
Applied rewrites28.1%
(FPCore (x1 y1 x2 y2)
:precision binary64
(let* ((t_0 (fmin (fabs x2) (fabs y2)))
(t_1 (fmax (fabs x2) (fabs y2))))
(*
(copysign 1.0 x1)
(if (<=
(/
(fabs x1)
(sqrt (+ (* (fabs x1) (fabs x1)) (* (fabs y1) (fabs y1)))))
0.995)
(* (/ -1.0 (fabs y1)) (* (* -1.0 t_1) (fabs x1)))
(* (sqrt (fma t_1 t_1 (* t_0 t_0))) 1.0)))))double code(double x1, double y1, double x2, double y2) {
double t_0 = fmin(fabs(x2), fabs(y2));
double t_1 = fmax(fabs(x2), fabs(y2));
double tmp;
if ((fabs(x1) / sqrt(((fabs(x1) * fabs(x1)) + (fabs(y1) * fabs(y1))))) <= 0.995) {
tmp = (-1.0 / fabs(y1)) * ((-1.0 * t_1) * fabs(x1));
} else {
tmp = sqrt(fma(t_1, t_1, (t_0 * t_0))) * 1.0;
}
return copysign(1.0, x1) * tmp;
}
function code(x1, y1, x2, y2) t_0 = (abs(x2) != abs(x2)) ? abs(y2) : ((abs(y2) != abs(y2)) ? abs(x2) : min(abs(x2), abs(y2))) t_1 = (abs(x2) != abs(x2)) ? abs(y2) : ((abs(y2) != abs(y2)) ? abs(x2) : max(abs(x2), abs(y2))) tmp = 0.0 if (Float64(abs(x1) / sqrt(Float64(Float64(abs(x1) * abs(x1)) + Float64(abs(y1) * abs(y1))))) <= 0.995) tmp = Float64(Float64(-1.0 / abs(y1)) * Float64(Float64(-1.0 * t_1) * abs(x1))); else tmp = Float64(sqrt(fma(t_1, t_1, Float64(t_0 * t_0))) * 1.0); end return Float64(copysign(1.0, x1) * tmp) end
code[x1_, y1_, x2_, y2_] := Block[{t$95$0 = N[Min[N[Abs[x2], $MachinePrecision], N[Abs[y2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Max[N[Abs[x2], $MachinePrecision], N[Abs[y2], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x1]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[Abs[x1], $MachinePrecision] / N[Sqrt[N[(N[(N[Abs[x1], $MachinePrecision] * N[Abs[x1], $MachinePrecision]), $MachinePrecision] + N[(N[Abs[y1], $MachinePrecision] * N[Abs[y1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.995], N[(N[(-1.0 / N[Abs[y1], $MachinePrecision]), $MachinePrecision] * N[(N[(-1.0 * t$95$1), $MachinePrecision] * N[Abs[x1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(t$95$1 * t$95$1 + N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 1.0), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \mathsf{min}\left(\left|x2\right|, \left|y2\right|\right)\\
t_1 := \mathsf{max}\left(\left|x2\right|, \left|y2\right|\right)\\
\mathsf{copysign}\left(1, x1\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{\left|x1\right|}{\sqrt{\left|x1\right| \cdot \left|x1\right| + \left|y1\right| \cdot \left|y1\right|}} \leq 0.995:\\
\;\;\;\;\frac{-1}{\left|y1\right|} \cdot \left(\left(-1 \cdot t\_1\right) \cdot \left|x1\right|\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(t\_1, t\_1, t\_0 \cdot t\_0\right)} \cdot 1\\
\end{array}
\end{array}
if (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) < 0.995Initial program 66.1%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
frac-2negN/A
associate-*r/N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites60.9%
Taylor expanded in y1 around inf
lower-/.f6424.1%
Applied rewrites24.1%
Taylor expanded in y2 around inf
lower-*.f6418.8%
Applied rewrites18.8%
if 0.995 < (/.f64 x1 (sqrt.f64 (+.f64 (*.f64 x1 x1) (*.f64 y1 y1)))) Initial program 66.1%
lift-sqrt.f64N/A
sqrt-fabs-revN/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lower-hypot.f6483.4%
Applied rewrites83.4%
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
sqrt-fabs-revN/A
pow1/2N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
rem-sqrt-square-revN/A
pow2N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
Applied rewrites99.8%
Taylor expanded in x1 around inf
Applied rewrites28.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6428.2%
lift-hypot.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
lift-sqrt.f6428.1%
Applied rewrites28.1%
(FPCore (x1 y1 x2 y2) :precision binary64 (* (/ -1.0 (fabs y1)) (* (* -1.0 (fmax (fabs x2) (fabs y2))) x1)))
double code(double x1, double y1, double x2, double y2) {
return (-1.0 / fabs(y1)) * ((-1.0 * fmax(fabs(x2), fabs(y2))) * x1);
}
real(8) function code(x1, y1, x2, y2)
real(8), intent (in) :: x1
real(8), intent (in) :: y1
real(8), intent (in) :: x2
real(8), intent (in) :: y2
code = ((-1.0d0) / abs(y1)) * (((-1.0d0) * merge(abs(y2), merge(abs(x2), max(abs(x2), abs(y2)), abs(y2) /= abs(y2)), abs(x2) /= abs(x2))) * x1)
end function
public static double code(double x1, double y1, double x2, double y2) {
return (-1.0 / Math.abs(y1)) * ((-1.0 * fmax(Math.abs(x2), Math.abs(y2))) * x1);
}
def code(x1, y1, x2, y2): return (-1.0 / math.fabs(y1)) * ((-1.0 * fmax(math.fabs(x2), math.fabs(y2))) * x1)
function code(x1, y1, x2, y2) return Float64(Float64(-1.0 / abs(y1)) * Float64(Float64(-1.0 * ((abs(x2) != abs(x2)) ? abs(y2) : ((abs(y2) != abs(y2)) ? abs(x2) : max(abs(x2), abs(y2))))) * x1)) end
function tmp = code(x1, y1, x2, y2) tmp = (-1.0 / abs(y1)) * ((-1.0 * max(abs(x2), abs(y2))) * x1); end
code[x1_, y1_, x2_, y2_] := N[(N[(-1.0 / N[Abs[y1], $MachinePrecision]), $MachinePrecision] * N[(N[(-1.0 * N[Max[N[Abs[x2], $MachinePrecision], N[Abs[y2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * x1), $MachinePrecision]), $MachinePrecision]
\frac{-1}{\left|y1\right|} \cdot \left(\left(-1 \cdot \mathsf{max}\left(\left|x2\right|, \left|y2\right|\right)\right) \cdot x1\right)
Initial program 66.1%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
frac-2negN/A
associate-*r/N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites60.9%
Taylor expanded in y1 around inf
lower-/.f6424.1%
Applied rewrites24.1%
Taylor expanded in y2 around inf
lower-*.f6418.8%
Applied rewrites18.8%
(FPCore (x1 y1 x2 y2) :precision binary64 (/ (* -1.0 (* x1 (fmax (fabs x2) (fabs y2)))) (- (fabs y1))))
double code(double x1, double y1, double x2, double y2) {
return (-1.0 * (x1 * fmax(fabs(x2), fabs(y2)))) / -fabs(y1);
}
real(8) function code(x1, y1, x2, y2)
real(8), intent (in) :: x1
real(8), intent (in) :: y1
real(8), intent (in) :: x2
real(8), intent (in) :: y2
code = ((-1.0d0) * (x1 * merge(abs(y2), merge(abs(x2), max(abs(x2), abs(y2)), abs(y2) /= abs(y2)), abs(x2) /= abs(x2)))) / -abs(y1)
end function
public static double code(double x1, double y1, double x2, double y2) {
return (-1.0 * (x1 * fmax(Math.abs(x2), Math.abs(y2)))) / -Math.abs(y1);
}
def code(x1, y1, x2, y2): return (-1.0 * (x1 * fmax(math.fabs(x2), math.fabs(y2)))) / -math.fabs(y1)
function code(x1, y1, x2, y2) return Float64(Float64(-1.0 * Float64(x1 * ((abs(x2) != abs(x2)) ? abs(y2) : ((abs(y2) != abs(y2)) ? abs(x2) : max(abs(x2), abs(y2)))))) / Float64(-abs(y1))) end
function tmp = code(x1, y1, x2, y2) tmp = (-1.0 * (x1 * max(abs(x2), abs(y2)))) / -abs(y1); end
code[x1_, y1_, x2_, y2_] := N[(N[(-1.0 * N[(x1 * N[Max[N[Abs[x2], $MachinePrecision], N[Abs[y2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / (-N[Abs[y1], $MachinePrecision])), $MachinePrecision]
\frac{-1 \cdot \left(x1 \cdot \mathsf{max}\left(\left|x2\right|, \left|y2\right|\right)\right)}{-\left|y1\right|}
Initial program 66.1%
Taylor expanded in y1 around -inf
lower-*.f6428.5%
Applied rewrites28.5%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
associate-*r/N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
lower-/.f64N/A
Applied rewrites24.0%
Taylor expanded in x2 around inf
lower-*.f6418.0%
Applied rewrites18.0%
Taylor expanded in y2 around -inf
lower-*.f64N/A
lower-*.f6418.8%
Applied rewrites18.8%
(FPCore (x1 y1 x2 y2) :precision binary64 (/ (* -1.0 (* x1 (fabs x2))) (- (fabs y1))))
double code(double x1, double y1, double x2, double y2) {
return (-1.0 * (x1 * fabs(x2))) / -fabs(y1);
}
real(8) function code(x1, y1, x2, y2)
real(8), intent (in) :: x1
real(8), intent (in) :: y1
real(8), intent (in) :: x2
real(8), intent (in) :: y2
code = ((-1.0d0) * (x1 * abs(x2))) / -abs(y1)
end function
public static double code(double x1, double y1, double x2, double y2) {
return (-1.0 * (x1 * Math.abs(x2))) / -Math.abs(y1);
}
def code(x1, y1, x2, y2): return (-1.0 * (x1 * math.fabs(x2))) / -math.fabs(y1)
function code(x1, y1, x2, y2) return Float64(Float64(-1.0 * Float64(x1 * abs(x2))) / Float64(-abs(y1))) end
function tmp = code(x1, y1, x2, y2) tmp = (-1.0 * (x1 * abs(x2))) / -abs(y1); end
code[x1_, y1_, x2_, y2_] := N[(N[(-1.0 * N[(x1 * N[Abs[x2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / (-N[Abs[y1], $MachinePrecision])), $MachinePrecision]
\frac{-1 \cdot \left(x1 \cdot \left|x2\right|\right)}{-\left|y1\right|}
Initial program 66.1%
Taylor expanded in y1 around -inf
lower-*.f6428.5%
Applied rewrites28.5%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
associate-*r/N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
lower-/.f64N/A
Applied rewrites24.0%
Taylor expanded in x2 around inf
lower-*.f6418.0%
Applied rewrites18.0%
Taylor expanded in x2 around -inf
lower-*.f64N/A
lower-*.f6418.4%
Applied rewrites18.4%
(FPCore (x1 y1 x2 y2) :precision binary64 (/ (* x1 x2) (- y1)))
double code(double x1, double y1, double x2, double y2) {
return (x1 * x2) / -y1;
}
real(8) function code(x1, y1, x2, y2)
real(8), intent (in) :: x1
real(8), intent (in) :: y1
real(8), intent (in) :: x2
real(8), intent (in) :: y2
code = (x1 * x2) / -y1
end function
public static double code(double x1, double y1, double x2, double y2) {
return (x1 * x2) / -y1;
}
def code(x1, y1, x2, y2): return (x1 * x2) / -y1
function code(x1, y1, x2, y2) return Float64(Float64(x1 * x2) / Float64(-y1)) end
function tmp = code(x1, y1, x2, y2) tmp = (x1 * x2) / -y1; end
code[x1_, y1_, x2_, y2_] := N[(N[(x1 * x2), $MachinePrecision] / (-y1)), $MachinePrecision]
\frac{x1 \cdot x2}{-y1}
Initial program 66.1%
Taylor expanded in y1 around -inf
lower-*.f6428.5%
Applied rewrites28.5%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
associate-*r/N/A
lift-sqrt.f64N/A
pow1/2N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
pow1/2N/A
lift-sqrt.f64N/A
lower-/.f64N/A
Applied rewrites24.0%
Taylor expanded in x2 around inf
lower-*.f6418.0%
Applied rewrites18.0%
herbie shell --seed 1
(FPCore (x1 y1 x2 y2)
:name "x1/sqrt(x1*x1+y1*y1)*sqrt(x2*x2+y2*y2)"
:precision binary64
:pre (and (and (and (and (<= -1000.0 x1) (<= x1 1000.0)) (and (<= -1000.0 y1) (<= y1 1000.0))) (and (<= -1000.0 x2) (<= x2 1000.0))) (and (<= -1000.0 y2) (<= y2 1000.0)))
(* (/ x1 (sqrt (+ (* x1 x1) (* y1 y1)))) (sqrt (+ (* x2 x2) (* y2 y2)))))