
(FPCore (x y) :precision binary64 (sqrt (fabs (- x y))))
double code(double x, double y) {
return sqrt(fabs((x - y)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt(abs((x - y)))
end function
public static double code(double x, double y) {
return Math.sqrt(Math.abs((x - y)));
}
def code(x, y): return math.sqrt(math.fabs((x - y)))
function code(x, y) return sqrt(abs(Float64(x - y))) end
function tmp = code(x, y) tmp = sqrt(abs((x - y))); end
code[x_, y_] := N[Sqrt[N[Abs[N[(x - y), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left|x - y\right|}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 3 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (sqrt (fabs (- x y))))
double code(double x, double y) {
return sqrt(fabs((x - y)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt(abs((x - y)))
end function
public static double code(double x, double y) {
return Math.sqrt(Math.abs((x - y)));
}
def code(x, y): return math.sqrt(math.fabs((x - y)))
function code(x, y) return sqrt(abs(Float64(x - y))) end
function tmp = code(x, y) tmp = sqrt(abs((x - y))); end
code[x_, y_] := N[Sqrt[N[Abs[N[(x - y), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\left|x - y\right|}
\end{array}
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (sqrt (- y x)))
assert(x < y);
double code(double x, double y) {
return sqrt((y - x));
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt((y - x))
end function
assert x < y;
public static double code(double x, double y) {
return Math.sqrt((y - x));
}
[x, y] = sort([x, y]) def code(x, y): return math.sqrt((y - x))
x, y = sort([x, y]) function code(x, y) return sqrt(Float64(y - x)) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = sqrt((y - x));
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[Sqrt[N[(y - x), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\sqrt{y - x}
\end{array}
Initial program 100.0%
lift-sqrt.f64N/A
lift-fabs.f64N/A
lift--.f64N/A
flip--N/A
fabs-divN/A
clear-numN/A
sqrt-divN/A
div-fabsN/A
metadata-evalN/A
lower-/.f64N/A
lower-sqrt.f64N/A
div-fabsN/A
neg-fabsN/A
div-fabsN/A
lower-fabs.f64N/A
clear-numN/A
Applied rewrites99.6%
lift-/.f64N/A
inv-powN/A
lift-sqrt.f64N/A
pow1/2N/A
pow-powN/A
lift-fabs.f64N/A
lift-/.f64N/A
inv-powN/A
sqr-powN/A
fabs-sqrN/A
sqr-powN/A
pow-powN/A
metadata-evalN/A
metadata-evalN/A
pow1/2N/A
lower-sqrt.f6451.6
Applied rewrites51.6%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= y 3.4e-187) (sqrt (- x)) (sqrt y)))
assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 3.4e-187) {
tmp = sqrt(-x);
} else {
tmp = sqrt(y);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 3.4d-187) then
tmp = sqrt(-x)
else
tmp = sqrt(y)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 3.4e-187) {
tmp = Math.sqrt(-x);
} else {
tmp = Math.sqrt(y);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 3.4e-187: tmp = math.sqrt(-x) else: tmp = math.sqrt(y) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 3.4e-187) tmp = sqrt(Float64(-x)); else tmp = sqrt(y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 3.4e-187)
tmp = sqrt(-x);
else
tmp = sqrt(y);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 3.4e-187], N[Sqrt[(-x)], $MachinePrecision], N[Sqrt[y], $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3.4 \cdot 10^{-187}:\\
\;\;\;\;\sqrt{-x}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{y}\\
\end{array}
\end{array}
if y < 3.4000000000000001e-187Initial program 100.0%
lift-sqrt.f64N/A
lift-fabs.f64N/A
lift--.f64N/A
flip--N/A
fabs-divN/A
clear-numN/A
sqrt-divN/A
div-fabsN/A
metadata-evalN/A
lower-/.f64N/A
lower-sqrt.f64N/A
div-fabsN/A
neg-fabsN/A
div-fabsN/A
lower-fabs.f64N/A
clear-numN/A
Applied rewrites99.6%
lift-/.f64N/A
inv-powN/A
lift-sqrt.f64N/A
pow1/2N/A
pow-powN/A
lift-fabs.f64N/A
lift-/.f64N/A
inv-powN/A
sqr-powN/A
fabs-sqrN/A
sqr-powN/A
pow-powN/A
metadata-evalN/A
metadata-evalN/A
pow1/2N/A
lower-sqrt.f6431.4
Applied rewrites31.4%
Taylor expanded in x around inf
mul-1-negN/A
lower-neg.f6431.5
Applied rewrites31.5%
if 3.4000000000000001e-187 < y Initial program 100.0%
lift-sqrt.f64N/A
lift-fabs.f64N/A
lift--.f64N/A
flip--N/A
fabs-divN/A
clear-numN/A
sqrt-divN/A
div-fabsN/A
metadata-evalN/A
lower-/.f64N/A
lower-sqrt.f64N/A
div-fabsN/A
neg-fabsN/A
div-fabsN/A
lower-fabs.f64N/A
clear-numN/A
Applied rewrites99.6%
lift-/.f64N/A
inv-powN/A
lift-sqrt.f64N/A
pow1/2N/A
pow-powN/A
lift-fabs.f64N/A
lift-/.f64N/A
inv-powN/A
sqr-powN/A
fabs-sqrN/A
sqr-powN/A
pow-powN/A
metadata-evalN/A
metadata-evalN/A
pow1/2N/A
lower-sqrt.f6483.0
Applied rewrites83.0%
Taylor expanded in x around 0
lower-sqrt.f6465.5
Applied rewrites65.5%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (sqrt y))
assert(x < y);
double code(double x, double y) {
return sqrt(y);
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt(y)
end function
assert x < y;
public static double code(double x, double y) {
return Math.sqrt(y);
}
[x, y] = sort([x, y]) def code(x, y): return math.sqrt(y)
x, y = sort([x, y]) function code(x, y) return sqrt(y) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = sqrt(y);
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[Sqrt[y], $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\sqrt{y}
\end{array}
Initial program 100.0%
lift-sqrt.f64N/A
lift-fabs.f64N/A
lift--.f64N/A
flip--N/A
fabs-divN/A
clear-numN/A
sqrt-divN/A
div-fabsN/A
metadata-evalN/A
lower-/.f64N/A
lower-sqrt.f64N/A
div-fabsN/A
neg-fabsN/A
div-fabsN/A
lower-fabs.f64N/A
clear-numN/A
Applied rewrites99.6%
lift-/.f64N/A
inv-powN/A
lift-sqrt.f64N/A
pow1/2N/A
pow-powN/A
lift-fabs.f64N/A
lift-/.f64N/A
inv-powN/A
sqr-powN/A
fabs-sqrN/A
sqr-powN/A
pow-powN/A
metadata-evalN/A
metadata-evalN/A
pow1/2N/A
lower-sqrt.f6451.6
Applied rewrites51.6%
Taylor expanded in x around 0
lower-sqrt.f6426.7
Applied rewrites26.7%
herbie shell --seed 2024313
(FPCore (x y)
:name "Optimisation.CirclePacking:place from circle-packing-0.1.0.4, C"
:precision binary64
(sqrt (fabs (- x y))))