
(FPCore (x y) :precision binary64 (/ (fabs (- x y)) (fabs y)))
double code(double x, double y) {
return fabs((x - y)) / fabs(y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = abs((x - y)) / abs(y)
end function
public static double code(double x, double y) {
return Math.abs((x - y)) / Math.abs(y);
}
def code(x, y): return math.fabs((x - y)) / math.fabs(y)
function code(x, y) return Float64(abs(Float64(x - y)) / abs(y)) end
function tmp = code(x, y) tmp = abs((x - y)) / abs(y); end
code[x_, y_] := N[(N[Abs[N[(x - y), $MachinePrecision]], $MachinePrecision] / N[Abs[y], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left|x - y\right|}{\left|y\right|}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (/ (fabs (- x y)) (fabs y)))
double code(double x, double y) {
return fabs((x - y)) / fabs(y);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = abs((x - y)) / abs(y)
end function
public static double code(double x, double y) {
return Math.abs((x - y)) / Math.abs(y);
}
def code(x, y): return math.fabs((x - y)) / math.fabs(y)
function code(x, y) return Float64(abs(Float64(x - y)) / abs(y)) end
function tmp = code(x, y) tmp = abs((x - y)) / abs(y); end
code[x_, y_] := N[(N[Abs[N[(x - y), $MachinePrecision]], $MachinePrecision] / N[Abs[y], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left|x - y\right|}{\left|y\right|}
\end{array}
(FPCore (x y) :precision binary64 (fabs (- 1.0 (/ x y))))
double code(double x, double y) {
return fabs((1.0 - (x / y)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = abs((1.0d0 - (x / y)))
end function
public static double code(double x, double y) {
return Math.abs((1.0 - (x / y)));
}
def code(x, y): return math.fabs((1.0 - (x / y)))
function code(x, y) return abs(Float64(1.0 - Float64(x / y))) end
function tmp = code(x, y) tmp = abs((1.0 - (x / y))); end
code[x_, y_] := N[Abs[N[(1.0 - N[(x / y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\left|1 - \frac{x}{y}\right|
\end{array}
Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-div100.0%
div-sub100.0%
*-inverses100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (or (<= y -4.5e-43) (not (<= y 1.25e-36))) (- 1.0 (/ x y)) (fabs (/ x y))))
double code(double x, double y) {
double tmp;
if ((y <= -4.5e-43) || !(y <= 1.25e-36)) {
tmp = 1.0 - (x / y);
} else {
tmp = fabs((x / y));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-4.5d-43)) .or. (.not. (y <= 1.25d-36))) then
tmp = 1.0d0 - (x / y)
else
tmp = abs((x / y))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -4.5e-43) || !(y <= 1.25e-36)) {
tmp = 1.0 - (x / y);
} else {
tmp = Math.abs((x / y));
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -4.5e-43) or not (y <= 1.25e-36): tmp = 1.0 - (x / y) else: tmp = math.fabs((x / y)) return tmp
function code(x, y) tmp = 0.0 if ((y <= -4.5e-43) || !(y <= 1.25e-36)) tmp = Float64(1.0 - Float64(x / y)); else tmp = abs(Float64(x / y)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -4.5e-43) || ~((y <= 1.25e-36))) tmp = 1.0 - (x / y); else tmp = abs((x / y)); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -4.5e-43], N[Not[LessEqual[y, 1.25e-36]], $MachinePrecision]], N[(1.0 - N[(x / y), $MachinePrecision]), $MachinePrecision], N[Abs[N[(x / y), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.5 \cdot 10^{-43} \lor \neg \left(y \leq 1.25 \cdot 10^{-36}\right):\\
\;\;\;\;1 - \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\left|\frac{x}{y}\right|\\
\end{array}
\end{array}
if y < -4.50000000000000025e-43 or 1.25000000000000001e-36 < y Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt10.8%
fabs-sqr10.8%
rem-square-sqrt12.2%
div-sub12.2%
sub-neg12.2%
*-inverses12.2%
metadata-eval12.2%
+-commutative12.2%
Simplified12.2%
+-commutative12.2%
metadata-eval12.2%
sub-neg12.2%
*-inverses12.2%
div-sub12.2%
clear-num12.1%
Applied egg-rr12.1%
remove-double-div12.1%
frac-2neg12.1%
metadata-eval12.1%
associate-/r/12.1%
metadata-eval12.1%
clear-num12.1%
distribute-neg-frac12.1%
metadata-eval12.1%
div-sub12.1%
*-inverses12.1%
sub-neg12.1%
metadata-eval12.1%
Applied egg-rr12.1%
neg-mul-112.1%
distribute-neg-frac212.1%
+-commutative12.1%
distribute-neg-in12.1%
metadata-eval12.1%
sub-neg12.1%
rem-square-sqrt1.3%
fabs-sqr1.3%
rem-square-sqrt1.4%
fabs-sub1.4%
sub-neg1.4%
metadata-eval1.4%
rem-square-sqrt0.1%
fabs-sqr0.1%
rem-square-sqrt89.2%
+-commutative89.2%
Simplified89.2%
Taylor expanded in x around 0 89.2%
mul-1-neg89.2%
sub-neg89.2%
Simplified89.2%
if -4.50000000000000025e-43 < y < 1.25000000000000001e-36Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-div100.0%
div-sub100.0%
*-inverses100.0%
Simplified100.0%
Taylor expanded in x around inf 82.3%
associate-*r/82.3%
neg-mul-182.3%
Simplified82.3%
Final simplification86.0%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ x (- y))))
(if (<= x -8.5e+145)
t_0
(if (<= x 7.4e-7)
1.0
(if (<= x 6.2e+114)
(/ x y)
(if (or (<= x 1.9e+133) (not (<= x 1.8e+211)))
t_0
(+ (/ x y) -1.0)))))))
double code(double x, double y) {
double t_0 = x / -y;
double tmp;
if (x <= -8.5e+145) {
tmp = t_0;
} else if (x <= 7.4e-7) {
tmp = 1.0;
} else if (x <= 6.2e+114) {
tmp = x / y;
} else if ((x <= 1.9e+133) || !(x <= 1.8e+211)) {
tmp = t_0;
} else {
tmp = (x / y) + -1.0;
}
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 = x / -y
if (x <= (-8.5d+145)) then
tmp = t_0
else if (x <= 7.4d-7) then
tmp = 1.0d0
else if (x <= 6.2d+114) then
tmp = x / y
else if ((x <= 1.9d+133) .or. (.not. (x <= 1.8d+211))) then
tmp = t_0
else
tmp = (x / y) + (-1.0d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = x / -y;
double tmp;
if (x <= -8.5e+145) {
tmp = t_0;
} else if (x <= 7.4e-7) {
tmp = 1.0;
} else if (x <= 6.2e+114) {
tmp = x / y;
} else if ((x <= 1.9e+133) || !(x <= 1.8e+211)) {
tmp = t_0;
} else {
tmp = (x / y) + -1.0;
}
return tmp;
}
def code(x, y): t_0 = x / -y tmp = 0 if x <= -8.5e+145: tmp = t_0 elif x <= 7.4e-7: tmp = 1.0 elif x <= 6.2e+114: tmp = x / y elif (x <= 1.9e+133) or not (x <= 1.8e+211): tmp = t_0 else: tmp = (x / y) + -1.0 return tmp
function code(x, y) t_0 = Float64(x / Float64(-y)) tmp = 0.0 if (x <= -8.5e+145) tmp = t_0; elseif (x <= 7.4e-7) tmp = 1.0; elseif (x <= 6.2e+114) tmp = Float64(x / y); elseif ((x <= 1.9e+133) || !(x <= 1.8e+211)) tmp = t_0; else tmp = Float64(Float64(x / y) + -1.0); end return tmp end
function tmp_2 = code(x, y) t_0 = x / -y; tmp = 0.0; if (x <= -8.5e+145) tmp = t_0; elseif (x <= 7.4e-7) tmp = 1.0; elseif (x <= 6.2e+114) tmp = x / y; elseif ((x <= 1.9e+133) || ~((x <= 1.8e+211))) tmp = t_0; else tmp = (x / y) + -1.0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(x / (-y)), $MachinePrecision]}, If[LessEqual[x, -8.5e+145], t$95$0, If[LessEqual[x, 7.4e-7], 1.0, If[LessEqual[x, 6.2e+114], N[(x / y), $MachinePrecision], If[Or[LessEqual[x, 1.9e+133], N[Not[LessEqual[x, 1.8e+211]], $MachinePrecision]], t$95$0, N[(N[(x / y), $MachinePrecision] + -1.0), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{-y}\\
\mathbf{if}\;x \leq -8.5 \cdot 10^{+145}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 7.4 \cdot 10^{-7}:\\
\;\;\;\;1\\
\mathbf{elif}\;x \leq 6.2 \cdot 10^{+114}:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{elif}\;x \leq 1.9 \cdot 10^{+133} \lor \neg \left(x \leq 1.8 \cdot 10^{+211}\right):\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} + -1\\
\end{array}
\end{array}
if x < -8.49999999999999977e145 or 6.2000000000000001e114 < x < 1.9000000000000001e133 or 1.80000000000000001e211 < x Initial program 99.9%
Taylor expanded in x around -inf 99.9%
fabs-neg99.9%
mul-1-neg99.9%
sub-neg99.9%
fabs-sub99.9%
fabs-div99.9%
rem-square-sqrt22.8%
fabs-sqr22.8%
rem-square-sqrt23.5%
div-sub23.5%
sub-neg23.5%
*-inverses23.5%
metadata-eval23.5%
+-commutative23.5%
Simplified23.5%
+-commutative23.5%
metadata-eval23.5%
sub-neg23.5%
*-inverses23.5%
div-sub23.5%
clear-num23.3%
Applied egg-rr23.3%
remove-double-div23.3%
frac-2neg23.3%
metadata-eval23.3%
associate-/r/23.3%
metadata-eval23.3%
clear-num23.4%
distribute-neg-frac23.4%
metadata-eval23.4%
div-sub23.4%
*-inverses23.4%
sub-neg23.4%
metadata-eval23.4%
Applied egg-rr23.4%
neg-mul-123.4%
distribute-neg-frac223.4%
+-commutative23.4%
distribute-neg-in23.4%
metadata-eval23.4%
sub-neg23.4%
rem-square-sqrt0.5%
fabs-sqr0.5%
rem-square-sqrt0.7%
fabs-sub0.7%
sub-neg0.7%
metadata-eval0.7%
rem-square-sqrt0.1%
fabs-sqr0.1%
rem-square-sqrt77.0%
+-commutative77.0%
Simplified77.0%
Taylor expanded in x around inf 61.4%
mul-1-neg61.4%
distribute-frac-neg261.4%
Simplified61.4%
if -8.49999999999999977e145 < x < 7.40000000000000009e-7Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt20.8%
fabs-sqr20.8%
rem-square-sqrt22.1%
div-sub22.1%
sub-neg22.1%
*-inverses22.1%
metadata-eval22.1%
+-commutative22.1%
Simplified22.1%
+-commutative22.1%
metadata-eval22.1%
sub-neg22.1%
*-inverses22.1%
div-sub22.1%
clear-num22.0%
Applied egg-rr22.0%
remove-double-div22.0%
frac-2neg22.0%
metadata-eval22.0%
associate-/r/22.0%
metadata-eval22.0%
clear-num22.0%
distribute-neg-frac22.0%
metadata-eval22.0%
div-sub22.0%
*-inverses22.0%
sub-neg22.0%
metadata-eval22.0%
Applied egg-rr22.0%
neg-mul-122.0%
distribute-neg-frac222.0%
+-commutative22.0%
distribute-neg-in22.0%
metadata-eval22.0%
sub-neg22.0%
rem-square-sqrt1.1%
fabs-sqr1.1%
rem-square-sqrt1.3%
fabs-sub1.3%
sub-neg1.3%
metadata-eval1.3%
rem-square-sqrt0.2%
fabs-sqr0.2%
rem-square-sqrt79.2%
+-commutative79.2%
Simplified79.2%
Taylor expanded in x around 0 64.9%
if 7.40000000000000009e-7 < x < 6.2000000000000001e114Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt59.8%
fabs-sqr59.8%
rem-square-sqrt60.5%
div-sub60.5%
sub-neg60.5%
*-inverses60.5%
metadata-eval60.5%
+-commutative60.5%
Simplified60.5%
Taylor expanded in x around inf 60.6%
if 1.9000000000000001e133 < x < 1.80000000000000001e211Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt68.2%
fabs-sqr68.2%
rem-square-sqrt68.9%
div-sub68.9%
sub-neg68.9%
*-inverses68.9%
metadata-eval68.9%
+-commutative68.9%
Simplified68.9%
Final simplification64.2%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ x (- y))))
(if (<= x -8.2e+145)
t_0
(if (<= x 8.6e-7)
1.0
(if (or (<= x 1.6e+114) (and (not (<= x 2.2e+132)) (<= x 8e+208)))
(/ x y)
t_0)))))
double code(double x, double y) {
double t_0 = x / -y;
double tmp;
if (x <= -8.2e+145) {
tmp = t_0;
} else if (x <= 8.6e-7) {
tmp = 1.0;
} else if ((x <= 1.6e+114) || (!(x <= 2.2e+132) && (x <= 8e+208))) {
tmp = x / y;
} else {
tmp = t_0;
}
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 = x / -y
if (x <= (-8.2d+145)) then
tmp = t_0
else if (x <= 8.6d-7) then
tmp = 1.0d0
else if ((x <= 1.6d+114) .or. (.not. (x <= 2.2d+132)) .and. (x <= 8d+208)) then
tmp = x / y
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = x / -y;
double tmp;
if (x <= -8.2e+145) {
tmp = t_0;
} else if (x <= 8.6e-7) {
tmp = 1.0;
} else if ((x <= 1.6e+114) || (!(x <= 2.2e+132) && (x <= 8e+208))) {
tmp = x / y;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = x / -y tmp = 0 if x <= -8.2e+145: tmp = t_0 elif x <= 8.6e-7: tmp = 1.0 elif (x <= 1.6e+114) or (not (x <= 2.2e+132) and (x <= 8e+208)): tmp = x / y else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(x / Float64(-y)) tmp = 0.0 if (x <= -8.2e+145) tmp = t_0; elseif (x <= 8.6e-7) tmp = 1.0; elseif ((x <= 1.6e+114) || (!(x <= 2.2e+132) && (x <= 8e+208))) tmp = Float64(x / y); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = x / -y; tmp = 0.0; if (x <= -8.2e+145) tmp = t_0; elseif (x <= 8.6e-7) tmp = 1.0; elseif ((x <= 1.6e+114) || (~((x <= 2.2e+132)) && (x <= 8e+208))) tmp = x / y; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(x / (-y)), $MachinePrecision]}, If[LessEqual[x, -8.2e+145], t$95$0, If[LessEqual[x, 8.6e-7], 1.0, If[Or[LessEqual[x, 1.6e+114], And[N[Not[LessEqual[x, 2.2e+132]], $MachinePrecision], LessEqual[x, 8e+208]]], N[(x / y), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{-y}\\
\mathbf{if}\;x \leq -8.2 \cdot 10^{+145}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 8.6 \cdot 10^{-7}:\\
\;\;\;\;1\\
\mathbf{elif}\;x \leq 1.6 \cdot 10^{+114} \lor \neg \left(x \leq 2.2 \cdot 10^{+132}\right) \land x \leq 8 \cdot 10^{+208}:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -8.2000000000000003e145 or 1.6e114 < x < 2.19999999999999989e132 or 7.9999999999999999e208 < x Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt23.3%
fabs-sqr23.3%
rem-square-sqrt23.9%
div-sub23.9%
sub-neg23.9%
*-inverses23.9%
metadata-eval23.9%
+-commutative23.9%
Simplified23.9%
+-commutative23.9%
metadata-eval23.9%
sub-neg23.9%
*-inverses23.9%
div-sub23.9%
clear-num23.8%
Applied egg-rr23.8%
remove-double-div23.8%
frac-2neg23.8%
metadata-eval23.8%
associate-/r/23.8%
metadata-eval23.8%
clear-num23.9%
distribute-neg-frac23.9%
metadata-eval23.9%
div-sub23.9%
*-inverses23.9%
sub-neg23.9%
metadata-eval23.9%
Applied egg-rr23.9%
neg-mul-123.9%
distribute-neg-frac223.9%
+-commutative23.9%
distribute-neg-in23.9%
metadata-eval23.9%
sub-neg23.9%
rem-square-sqrt0.5%
fabs-sqr0.5%
rem-square-sqrt0.7%
fabs-sub0.7%
sub-neg0.7%
metadata-eval0.7%
rem-square-sqrt0.1%
fabs-sqr0.1%
rem-square-sqrt76.5%
+-commutative76.5%
Simplified76.5%
Taylor expanded in x around inf 62.7%
mul-1-neg62.7%
distribute-frac-neg262.7%
Simplified62.7%
if -8.2000000000000003e145 < x < 8.6000000000000002e-7Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt20.8%
fabs-sqr20.8%
rem-square-sqrt22.1%
div-sub22.1%
sub-neg22.1%
*-inverses22.1%
metadata-eval22.1%
+-commutative22.1%
Simplified22.1%
+-commutative22.1%
metadata-eval22.1%
sub-neg22.1%
*-inverses22.1%
div-sub22.1%
clear-num22.0%
Applied egg-rr22.0%
remove-double-div22.0%
frac-2neg22.0%
metadata-eval22.0%
associate-/r/22.0%
metadata-eval22.0%
clear-num22.0%
distribute-neg-frac22.0%
metadata-eval22.0%
div-sub22.0%
*-inverses22.0%
sub-neg22.0%
metadata-eval22.0%
Applied egg-rr22.0%
neg-mul-122.0%
distribute-neg-frac222.0%
+-commutative22.0%
distribute-neg-in22.0%
metadata-eval22.0%
sub-neg22.0%
rem-square-sqrt1.1%
fabs-sqr1.1%
rem-square-sqrt1.3%
fabs-sub1.3%
sub-neg1.3%
metadata-eval1.3%
rem-square-sqrt0.2%
fabs-sqr0.2%
rem-square-sqrt79.2%
+-commutative79.2%
Simplified79.2%
Taylor expanded in x around 0 64.9%
if 8.6000000000000002e-7 < x < 1.6e114 or 2.19999999999999989e132 < x < 7.9999999999999999e208Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt61.8%
fabs-sqr61.8%
rem-square-sqrt62.6%
div-sub62.6%
sub-neg62.6%
*-inverses62.6%
metadata-eval62.6%
+-commutative62.6%
Simplified62.6%
Taylor expanded in x around inf 61.3%
Final simplification64.0%
(FPCore (x y) :precision binary64 (if (or (<= y -1.9e-209) (not (<= y 4e-242))) (- 1.0 (/ x y)) (+ (/ x y) -1.0)))
double code(double x, double y) {
double tmp;
if ((y <= -1.9e-209) || !(y <= 4e-242)) {
tmp = 1.0 - (x / y);
} else {
tmp = (x / y) + -1.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-1.9d-209)) .or. (.not. (y <= 4d-242))) then
tmp = 1.0d0 - (x / y)
else
tmp = (x / y) + (-1.0d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -1.9e-209) || !(y <= 4e-242)) {
tmp = 1.0 - (x / y);
} else {
tmp = (x / y) + -1.0;
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -1.9e-209) or not (y <= 4e-242): tmp = 1.0 - (x / y) else: tmp = (x / y) + -1.0 return tmp
function code(x, y) tmp = 0.0 if ((y <= -1.9e-209) || !(y <= 4e-242)) tmp = Float64(1.0 - Float64(x / y)); else tmp = Float64(Float64(x / y) + -1.0); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -1.9e-209) || ~((y <= 4e-242))) tmp = 1.0 - (x / y); else tmp = (x / y) + -1.0; end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -1.9e-209], N[Not[LessEqual[y, 4e-242]], $MachinePrecision]], N[(1.0 - N[(x / y), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] + -1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.9 \cdot 10^{-209} \lor \neg \left(y \leq 4 \cdot 10^{-242}\right):\\
\;\;\;\;1 - \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} + -1\\
\end{array}
\end{array}
if y < -1.8999999999999999e-209 or 4e-242 < y Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt19.4%
fabs-sqr19.4%
rem-square-sqrt20.6%
div-sub20.6%
sub-neg20.6%
*-inverses20.6%
metadata-eval20.6%
+-commutative20.6%
Simplified20.6%
+-commutative20.6%
metadata-eval20.6%
sub-neg20.6%
*-inverses20.6%
div-sub20.6%
clear-num20.5%
Applied egg-rr20.5%
remove-double-div20.5%
frac-2neg20.5%
metadata-eval20.5%
associate-/r/20.5%
metadata-eval20.5%
clear-num20.5%
distribute-neg-frac20.5%
metadata-eval20.5%
div-sub20.6%
*-inverses20.6%
sub-neg20.6%
metadata-eval20.6%
Applied egg-rr20.6%
neg-mul-120.6%
distribute-neg-frac220.6%
+-commutative20.6%
distribute-neg-in20.6%
metadata-eval20.6%
sub-neg20.6%
rem-square-sqrt1.1%
fabs-sqr1.1%
rem-square-sqrt1.2%
fabs-sub1.2%
sub-neg1.2%
metadata-eval1.2%
rem-square-sqrt0.2%
fabs-sqr0.2%
rem-square-sqrt80.6%
+-commutative80.6%
Simplified80.6%
Taylor expanded in x around 0 80.6%
mul-1-neg80.6%
sub-neg80.6%
Simplified80.6%
if -1.8999999999999999e-209 < y < 4e-242Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt68.1%
fabs-sqr68.1%
rem-square-sqrt68.5%
div-sub68.4%
sub-neg68.4%
*-inverses68.4%
metadata-eval68.4%
+-commutative68.4%
Simplified68.4%
Final simplification78.7%
(FPCore (x y) :precision binary64 (if (or (<= y -1.85e-209) (not (<= y 3.4e-242))) (- 1.0 (/ x y)) (/ (- x y) y)))
double code(double x, double y) {
double tmp;
if ((y <= -1.85e-209) || !(y <= 3.4e-242)) {
tmp = 1.0 - (x / y);
} else {
tmp = (x - y) / y;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-1.85d-209)) .or. (.not. (y <= 3.4d-242))) then
tmp = 1.0d0 - (x / y)
else
tmp = (x - y) / y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -1.85e-209) || !(y <= 3.4e-242)) {
tmp = 1.0 - (x / y);
} else {
tmp = (x - y) / y;
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -1.85e-209) or not (y <= 3.4e-242): tmp = 1.0 - (x / y) else: tmp = (x - y) / y return tmp
function code(x, y) tmp = 0.0 if ((y <= -1.85e-209) || !(y <= 3.4e-242)) tmp = Float64(1.0 - Float64(x / y)); else tmp = Float64(Float64(x - y) / y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -1.85e-209) || ~((y <= 3.4e-242))) tmp = 1.0 - (x / y); else tmp = (x - y) / y; end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -1.85e-209], N[Not[LessEqual[y, 3.4e-242]], $MachinePrecision]], N[(1.0 - N[(x / y), $MachinePrecision]), $MachinePrecision], N[(N[(x - y), $MachinePrecision] / y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.85 \cdot 10^{-209} \lor \neg \left(y \leq 3.4 \cdot 10^{-242}\right):\\
\;\;\;\;1 - \frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x - y}{y}\\
\end{array}
\end{array}
if y < -1.8499999999999999e-209 or 3.4000000000000001e-242 < y Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt19.4%
fabs-sqr19.4%
rem-square-sqrt20.6%
div-sub20.6%
sub-neg20.6%
*-inverses20.6%
metadata-eval20.6%
+-commutative20.6%
Simplified20.6%
+-commutative20.6%
metadata-eval20.6%
sub-neg20.6%
*-inverses20.6%
div-sub20.6%
clear-num20.5%
Applied egg-rr20.5%
remove-double-div20.5%
frac-2neg20.5%
metadata-eval20.5%
associate-/r/20.5%
metadata-eval20.5%
clear-num20.5%
distribute-neg-frac20.5%
metadata-eval20.5%
div-sub20.6%
*-inverses20.6%
sub-neg20.6%
metadata-eval20.6%
Applied egg-rr20.6%
neg-mul-120.6%
distribute-neg-frac220.6%
+-commutative20.6%
distribute-neg-in20.6%
metadata-eval20.6%
sub-neg20.6%
rem-square-sqrt1.1%
fabs-sqr1.1%
rem-square-sqrt1.2%
fabs-sub1.2%
sub-neg1.2%
metadata-eval1.2%
rem-square-sqrt0.2%
fabs-sqr0.2%
rem-square-sqrt80.6%
+-commutative80.6%
Simplified80.6%
Taylor expanded in x around 0 80.6%
mul-1-neg80.6%
sub-neg80.6%
Simplified80.6%
if -1.8499999999999999e-209 < y < 3.4000000000000001e-242Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt68.1%
fabs-sqr68.1%
rem-square-sqrt68.5%
div-sub68.4%
sub-neg68.4%
*-inverses68.4%
metadata-eval68.4%
+-commutative68.4%
Simplified68.4%
+-commutative68.4%
metadata-eval68.4%
sub-neg68.4%
*-inverses68.4%
div-sub68.5%
Applied egg-rr68.5%
Final simplification78.7%
(FPCore (x y) :precision binary64 (if (<= y -5.5e-48) 1.0 (if (<= y 4.2e-98) (/ x y) 1.0)))
double code(double x, double y) {
double tmp;
if (y <= -5.5e-48) {
tmp = 1.0;
} else if (y <= 4.2e-98) {
tmp = x / y;
} else {
tmp = 1.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= (-5.5d-48)) then
tmp = 1.0d0
else if (y <= 4.2d-98) then
tmp = x / y
else
tmp = 1.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -5.5e-48) {
tmp = 1.0;
} else if (y <= 4.2e-98) {
tmp = x / y;
} else {
tmp = 1.0;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -5.5e-48: tmp = 1.0 elif y <= 4.2e-98: tmp = x / y else: tmp = 1.0 return tmp
function code(x, y) tmp = 0.0 if (y <= -5.5e-48) tmp = 1.0; elseif (y <= 4.2e-98) tmp = Float64(x / y); else tmp = 1.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -5.5e-48) tmp = 1.0; elseif (y <= 4.2e-98) tmp = x / y; else tmp = 1.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -5.5e-48], 1.0, If[LessEqual[y, 4.2e-98], N[(x / y), $MachinePrecision], 1.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.5 \cdot 10^{-48}:\\
\;\;\;\;1\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{-98}:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;1\\
\end{array}
\end{array}
if y < -5.50000000000000047e-48 or 4.19999999999999984e-98 < y Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt13.3%
fabs-sqr13.3%
rem-square-sqrt14.7%
div-sub14.7%
sub-neg14.7%
*-inverses14.7%
metadata-eval14.7%
+-commutative14.7%
Simplified14.7%
+-commutative14.7%
metadata-eval14.7%
sub-neg14.7%
*-inverses14.7%
div-sub14.7%
clear-num14.6%
Applied egg-rr14.6%
remove-double-div14.6%
frac-2neg14.6%
metadata-eval14.6%
associate-/r/14.6%
metadata-eval14.6%
clear-num14.7%
distribute-neg-frac14.7%
metadata-eval14.7%
div-sub14.7%
*-inverses14.7%
sub-neg14.7%
metadata-eval14.7%
Applied egg-rr14.7%
neg-mul-114.7%
distribute-neg-frac214.7%
+-commutative14.7%
distribute-neg-in14.7%
metadata-eval14.7%
sub-neg14.7%
rem-square-sqrt1.3%
fabs-sqr1.3%
rem-square-sqrt1.4%
fabs-sub1.4%
sub-neg1.4%
metadata-eval1.4%
rem-square-sqrt0.1%
fabs-sqr0.1%
rem-square-sqrt86.6%
+-commutative86.6%
Simplified86.6%
Taylor expanded in x around 0 69.3%
if -5.50000000000000047e-48 < y < 4.19999999999999984e-98Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt48.8%
fabs-sqr48.8%
rem-square-sqrt49.4%
div-sub49.4%
sub-neg49.4%
*-inverses49.4%
metadata-eval49.4%
+-commutative49.4%
Simplified49.4%
Taylor expanded in x around inf 48.6%
Final simplification61.2%
(FPCore (x y) :precision binary64 -1.0)
double code(double x, double y) {
return -1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = -1.0d0
end function
public static double code(double x, double y) {
return -1.0;
}
def code(x, y): return -1.0
function code(x, y) return -1.0 end
function tmp = code(x, y) tmp = -1.0; end
code[x_, y_] := -1.0
\begin{array}{l}
\\
-1
\end{array}
Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt27.2%
fabs-sqr27.2%
rem-square-sqrt28.3%
div-sub28.3%
sub-neg28.3%
*-inverses28.3%
metadata-eval28.3%
+-commutative28.3%
Simplified28.3%
Taylor expanded in x around 0 1.3%
Final simplification1.3%
(FPCore (x y) :precision binary64 1.0)
double code(double x, double y) {
return 1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0
end function
public static double code(double x, double y) {
return 1.0;
}
def code(x, y): return 1.0
function code(x, y) return 1.0 end
function tmp = code(x, y) tmp = 1.0; end
code[x_, y_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 100.0%
Taylor expanded in x around -inf 100.0%
fabs-neg100.0%
mul-1-neg100.0%
sub-neg100.0%
fabs-sub100.0%
fabs-div100.0%
rem-square-sqrt27.2%
fabs-sqr27.2%
rem-square-sqrt28.3%
div-sub28.3%
sub-neg28.3%
*-inverses28.3%
metadata-eval28.3%
+-commutative28.3%
Simplified28.3%
+-commutative28.3%
metadata-eval28.3%
sub-neg28.3%
*-inverses28.3%
div-sub28.3%
clear-num28.2%
Applied egg-rr28.2%
remove-double-div28.2%
frac-2neg28.2%
metadata-eval28.2%
associate-/r/28.2%
metadata-eval28.2%
clear-num28.2%
distribute-neg-frac28.2%
metadata-eval28.2%
div-sub28.2%
*-inverses28.2%
sub-neg28.2%
metadata-eval28.2%
Applied egg-rr28.2%
neg-mul-128.2%
distribute-neg-frac228.2%
+-commutative28.2%
distribute-neg-in28.2%
metadata-eval28.2%
sub-neg28.2%
rem-square-sqrt0.9%
fabs-sqr0.9%
rem-square-sqrt1.1%
fabs-sub1.1%
sub-neg1.1%
metadata-eval1.1%
rem-square-sqrt0.2%
fabs-sqr0.2%
rem-square-sqrt72.8%
+-commutative72.8%
Simplified72.8%
Taylor expanded in x around 0 49.1%
Final simplification49.1%
herbie shell --seed 2024053
(FPCore (x y)
:name "Numeric.LinearAlgebra.Util:formatSparse from hmatrix-0.16.1.5"
:precision binary64
(/ (fabs (- x y)) (fabs y)))