
(FPCore (x y) :precision binary64 (+ x (* (- 1.0 x) (- 1.0 y))))
double code(double x, double y) {
return x + ((1.0 - x) * (1.0 - y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x + ((1.0d0 - x) * (1.0d0 - y))
end function
public static double code(double x, double y) {
return x + ((1.0 - x) * (1.0 - y));
}
def code(x, y): return x + ((1.0 - x) * (1.0 - y))
function code(x, y) return Float64(x + Float64(Float64(1.0 - x) * Float64(1.0 - y))) end
function tmp = code(x, y) tmp = x + ((1.0 - x) * (1.0 - y)); end
code[x_, y_] := N[(x + N[(N[(1.0 - x), $MachinePrecision] * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(1 - x\right) \cdot \left(1 - y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 7 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (+ x (* (- 1.0 x) (- 1.0 y))))
double code(double x, double y) {
return x + ((1.0 - x) * (1.0 - y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x + ((1.0d0 - x) * (1.0d0 - y))
end function
public static double code(double x, double y) {
return x + ((1.0 - x) * (1.0 - y));
}
def code(x, y): return x + ((1.0 - x) * (1.0 - y))
function code(x, y) return Float64(x + Float64(Float64(1.0 - x) * Float64(1.0 - y))) end
function tmp = code(x, y) tmp = x + ((1.0 - x) * (1.0 - y)); end
code[x_, y_] := N[(x + N[(N[(1.0 - x), $MachinePrecision] * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(1 - x\right) \cdot \left(1 - y\right)
\end{array}
(FPCore (x y) :precision binary64 (- (+ 1.0 (* y x)) y))
double code(double x, double y) {
return (1.0 + (y * x)) - y;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (1.0d0 + (y * x)) - y
end function
public static double code(double x, double y) {
return (1.0 + (y * x)) - y;
}
def code(x, y): return (1.0 + (y * x)) - y
function code(x, y) return Float64(Float64(1.0 + Float64(y * x)) - y) end
function tmp = code(x, y) tmp = (1.0 + (y * x)) - y; end
code[x_, y_] := N[(N[(1.0 + N[(y * x), $MachinePrecision]), $MachinePrecision] - y), $MachinePrecision]
\begin{array}{l}
\\
\left(1 + y \cdot x\right) - y
\end{array}
Initial program 77.4%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
distribute-rgt-inN/A
associate-+r+N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64100.0%
Applied egg-rr100.0%
(FPCore (x y) :precision binary64 (if (<= y -1.0) (- 0.0 y) (if (<= y 3.9e-56) 1.0 (if (<= y 7.5e+102) (* y x) (- 0.0 y)))))
double code(double x, double y) {
double tmp;
if (y <= -1.0) {
tmp = 0.0 - y;
} else if (y <= 3.9e-56) {
tmp = 1.0;
} else if (y <= 7.5e+102) {
tmp = y * x;
} else {
tmp = 0.0 - 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.0d0)) then
tmp = 0.0d0 - y
else if (y <= 3.9d-56) then
tmp = 1.0d0
else if (y <= 7.5d+102) then
tmp = y * x
else
tmp = 0.0d0 - y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -1.0) {
tmp = 0.0 - y;
} else if (y <= 3.9e-56) {
tmp = 1.0;
} else if (y <= 7.5e+102) {
tmp = y * x;
} else {
tmp = 0.0 - y;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -1.0: tmp = 0.0 - y elif y <= 3.9e-56: tmp = 1.0 elif y <= 7.5e+102: tmp = y * x else: tmp = 0.0 - y return tmp
function code(x, y) tmp = 0.0 if (y <= -1.0) tmp = Float64(0.0 - y); elseif (y <= 3.9e-56) tmp = 1.0; elseif (y <= 7.5e+102) tmp = Float64(y * x); else tmp = Float64(0.0 - y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -1.0) tmp = 0.0 - y; elseif (y <= 3.9e-56) tmp = 1.0; elseif (y <= 7.5e+102) tmp = y * x; else tmp = 0.0 - y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -1.0], N[(0.0 - y), $MachinePrecision], If[LessEqual[y, 3.9e-56], 1.0, If[LessEqual[y, 7.5e+102], N[(y * x), $MachinePrecision], N[(0.0 - y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1:\\
\;\;\;\;0 - y\\
\mathbf{elif}\;y \leq 3.9 \cdot 10^{-56}:\\
\;\;\;\;1\\
\mathbf{elif}\;y \leq 7.5 \cdot 10^{+102}:\\
\;\;\;\;y \cdot x\\
\mathbf{else}:\\
\;\;\;\;0 - y\\
\end{array}
\end{array}
if y < -1 or 7.5e102 < y Initial program 100.0%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in x around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f6463.5%
Simplified63.5%
Taylor expanded in y around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6463.3%
Simplified63.3%
sub0-negN/A
neg-lowering-neg.f6463.3%
Applied egg-rr63.3%
if -1 < y < 3.9e-56Initial program 59.5%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in y around 0
Simplified78.7%
if 3.9e-56 < y < 7.5e102Initial program 85.1%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in x around inf
*-commutativeN/A
*-lowering-*.f6462.0%
Simplified62.0%
Final simplification70.8%
(FPCore (x y) :precision binary64 (let* ((t_0 (+ 1.0 (* y x)))) (if (<= x -290.0) t_0 (if (<= x 5.8e-21) (- 1.0 y) t_0))))
double code(double x, double y) {
double t_0 = 1.0 + (y * x);
double tmp;
if (x <= -290.0) {
tmp = t_0;
} else if (x <= 5.8e-21) {
tmp = 1.0 - 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 = 1.0d0 + (y * x)
if (x <= (-290.0d0)) then
tmp = t_0
else if (x <= 5.8d-21) then
tmp = 1.0d0 - y
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = 1.0 + (y * x);
double tmp;
if (x <= -290.0) {
tmp = t_0;
} else if (x <= 5.8e-21) {
tmp = 1.0 - y;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = 1.0 + (y * x) tmp = 0 if x <= -290.0: tmp = t_0 elif x <= 5.8e-21: tmp = 1.0 - y else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(1.0 + Float64(y * x)) tmp = 0.0 if (x <= -290.0) tmp = t_0; elseif (x <= 5.8e-21) tmp = Float64(1.0 - y); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = 1.0 + (y * x); tmp = 0.0; if (x <= -290.0) tmp = t_0; elseif (x <= 5.8e-21) tmp = 1.0 - y; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(1.0 + N[(y * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -290.0], t$95$0, If[LessEqual[x, 5.8e-21], N[(1.0 - y), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + y \cdot x\\
\mathbf{if}\;x \leq -290:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 5.8 \cdot 10^{-21}:\\
\;\;\;\;1 - y\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -290 or 5.8e-21 < x Initial program 49.8%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in x around inf
*-commutativeN/A
*-lowering-*.f6499.5%
Simplified99.5%
if -290 < x < 5.8e-21Initial program 100.0%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in x around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f6499.1%
Simplified99.1%
(FPCore (x y) :precision binary64 (if (<= x -8.2e+35) (* y x) (if (<= x 1e+15) (- 1.0 y) (* y x))))
double code(double x, double y) {
double tmp;
if (x <= -8.2e+35) {
tmp = y * x;
} else if (x <= 1e+15) {
tmp = 1.0 - y;
} else {
tmp = y * x;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-8.2d+35)) then
tmp = y * x
else if (x <= 1d+15) then
tmp = 1.0d0 - y
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -8.2e+35) {
tmp = y * x;
} else if (x <= 1e+15) {
tmp = 1.0 - y;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -8.2e+35: tmp = y * x elif x <= 1e+15: tmp = 1.0 - y else: tmp = y * x return tmp
function code(x, y) tmp = 0.0 if (x <= -8.2e+35) tmp = Float64(y * x); elseif (x <= 1e+15) tmp = Float64(1.0 - y); else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -8.2e+35) tmp = y * x; elseif (x <= 1e+15) tmp = 1.0 - y; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -8.2e+35], N[(y * x), $MachinePrecision], If[LessEqual[x, 1e+15], N[(1.0 - y), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -8.2 \cdot 10^{+35}:\\
\;\;\;\;y \cdot x\\
\mathbf{elif}\;x \leq 10^{+15}:\\
\;\;\;\;1 - y\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if x < -8.1999999999999997e35 or 1e15 < x Initial program 48.8%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in x around inf
*-commutativeN/A
*-lowering-*.f6476.0%
Simplified76.0%
if -8.1999999999999997e35 < x < 1e15Initial program 98.0%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in x around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f6497.9%
Simplified97.9%
(FPCore (x y) :precision binary64 (if (<= y -1.0) (- 0.0 y) (if (<= y 1.8e-7) 1.0 (- 0.0 y))))
double code(double x, double y) {
double tmp;
if (y <= -1.0) {
tmp = 0.0 - y;
} else if (y <= 1.8e-7) {
tmp = 1.0;
} else {
tmp = 0.0 - 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.0d0)) then
tmp = 0.0d0 - y
else if (y <= 1.8d-7) then
tmp = 1.0d0
else
tmp = 0.0d0 - y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -1.0) {
tmp = 0.0 - y;
} else if (y <= 1.8e-7) {
tmp = 1.0;
} else {
tmp = 0.0 - y;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -1.0: tmp = 0.0 - y elif y <= 1.8e-7: tmp = 1.0 else: tmp = 0.0 - y return tmp
function code(x, y) tmp = 0.0 if (y <= -1.0) tmp = Float64(0.0 - y); elseif (y <= 1.8e-7) tmp = 1.0; else tmp = Float64(0.0 - y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -1.0) tmp = 0.0 - y; elseif (y <= 1.8e-7) tmp = 1.0; else tmp = 0.0 - y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -1.0], N[(0.0 - y), $MachinePrecision], If[LessEqual[y, 1.8e-7], 1.0, N[(0.0 - y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1:\\
\;\;\;\;0 - y\\
\mathbf{elif}\;y \leq 1.8 \cdot 10^{-7}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;0 - y\\
\end{array}
\end{array}
if y < -1 or 1.79999999999999997e-7 < y Initial program 99.7%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in x around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f6457.3%
Simplified57.3%
Taylor expanded in y around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6456.4%
Simplified56.4%
sub0-negN/A
neg-lowering-neg.f6456.4%
Applied egg-rr56.4%
if -1 < y < 1.79999999999999997e-7Initial program 58.4%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in y around 0
Simplified75.7%
Final simplification66.8%
(FPCore (x y) :precision binary64 (+ 1.0 (* y (+ x -1.0))))
double code(double x, double y) {
return 1.0 + (y * (x + -1.0));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 1.0d0 + (y * (x + (-1.0d0)))
end function
public static double code(double x, double y) {
return 1.0 + (y * (x + -1.0));
}
def code(x, y): return 1.0 + (y * (x + -1.0))
function code(x, y) return Float64(1.0 + Float64(y * Float64(x + -1.0))) end
function tmp = code(x, y) tmp = 1.0 + (y * (x + -1.0)); end
code[x_, y_] := N[(1.0 + N[(y * N[(x + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + y \cdot \left(x + -1\right)
\end{array}
Initial program 77.4%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
(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 77.4%
sub-negN/A
distribute-rgt-inN/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
associate-+r+N/A
*-lft-identityN/A
neg-mul-1N/A
distribute-rgt1-inN/A
metadata-evalN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
*-lft-identityN/A
mul0-lftN/A
+-lft-identityN/A
+-lowering-+.f64N/A
*-commutativeN/A
neg-mul-1N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified100.0%
Taylor expanded in y around 0
Simplified42.0%
(FPCore (x y) :precision binary64 (- (* y x) (- y 1.0)))
double code(double x, double y) {
return (y * x) - (y - 1.0);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (y * x) - (y - 1.0d0)
end function
public static double code(double x, double y) {
return (y * x) - (y - 1.0);
}
def code(x, y): return (y * x) - (y - 1.0)
function code(x, y) return Float64(Float64(y * x) - Float64(y - 1.0)) end
function tmp = code(x, y) tmp = (y * x) - (y - 1.0); end
code[x_, y_] := N[(N[(y * x), $MachinePrecision] - N[(y - 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
y \cdot x - \left(y - 1\right)
\end{array}
herbie shell --seed 2024160
(FPCore (x y)
:name "Graphics.Rendering.Chart.Plot.Vectors:renderPlotVectors from Chart-1.5.3"
:precision binary64
:alt
(! :herbie-platform default (- (* y x) (- y 1)))
(+ x (* (- 1.0 x) (- 1.0 y))))