
(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 78.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%
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 (let* ((t_0 (+ 1.0 (* y x)))) (if (<= x -1400.0) t_0 (if (<= x 1.3e-8) (- 1.0 y) t_0))))
double code(double x, double y) {
double t_0 = 1.0 + (y * x);
double tmp;
if (x <= -1400.0) {
tmp = t_0;
} else if (x <= 1.3e-8) {
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 <= (-1400.0d0)) then
tmp = t_0
else if (x <= 1.3d-8) 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 <= -1400.0) {
tmp = t_0;
} else if (x <= 1.3e-8) {
tmp = 1.0 - y;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = 1.0 + (y * x) tmp = 0 if x <= -1400.0: tmp = t_0 elif x <= 1.3e-8: 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 <= -1400.0) tmp = t_0; elseif (x <= 1.3e-8) 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 <= -1400.0) tmp = t_0; elseif (x <= 1.3e-8) 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, -1400.0], t$95$0, If[LessEqual[x, 1.3e-8], N[(1.0 - y), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 1 + y \cdot x\\
\mathbf{if}\;x \leq -1400:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{-8}:\\
\;\;\;\;1 - y\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -1400 or 1.3000000000000001e-8 < x Initial program 54.2%
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.4%
Simplified99.4%
if -1400 < x < 1.3000000000000001e-8Initial 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--.f6498.7%
Simplified98.7%
(FPCore (x y) :precision binary64 (if (<= x -3.4e+93) (* y x) (if (<= x 9.6) (- 1.0 y) (* y (+ x -1.0)))))
double code(double x, double y) {
double tmp;
if (x <= -3.4e+93) {
tmp = y * x;
} else if (x <= 9.6) {
tmp = 1.0 - y;
} else {
tmp = y * (x + -1.0);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-3.4d+93)) then
tmp = y * x
else if (x <= 9.6d0) then
tmp = 1.0d0 - y
else
tmp = y * (x + (-1.0d0))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -3.4e+93) {
tmp = y * x;
} else if (x <= 9.6) {
tmp = 1.0 - y;
} else {
tmp = y * (x + -1.0);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -3.4e+93: tmp = y * x elif x <= 9.6: tmp = 1.0 - y else: tmp = y * (x + -1.0) return tmp
function code(x, y) tmp = 0.0 if (x <= -3.4e+93) tmp = Float64(y * x); elseif (x <= 9.6) tmp = Float64(1.0 - y); else tmp = Float64(y * Float64(x + -1.0)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -3.4e+93) tmp = y * x; elseif (x <= 9.6) tmp = 1.0 - y; else tmp = y * (x + -1.0); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -3.4e+93], N[(y * x), $MachinePrecision], If[LessEqual[x, 9.6], N[(1.0 - y), $MachinePrecision], N[(y * N[(x + -1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.4 \cdot 10^{+93}:\\
\;\;\;\;y \cdot x\\
\mathbf{elif}\;x \leq 9.6:\\
\;\;\;\;1 - y\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x + -1\right)\\
\end{array}
\end{array}
if x < -3.4e93Initial program 49.9%
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-*.f6490.2%
Simplified90.2%
if -3.4e93 < x < 9.59999999999999964Initial program 94.2%
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--.f6494.1%
Simplified94.1%
if 9.59999999999999964 < x Initial program 57.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 inf
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f6482.8%
Simplified82.8%
(FPCore (x y) :precision binary64 (if (<= x -1.55e+93) (* y x) (if (<= x 2.2e+16) (- 1.0 y) (* y x))))
double code(double x, double y) {
double tmp;
if (x <= -1.55e+93) {
tmp = y * x;
} else if (x <= 2.2e+16) {
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 <= (-1.55d+93)) then
tmp = y * x
else if (x <= 2.2d+16) 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 <= -1.55e+93) {
tmp = y * x;
} else if (x <= 2.2e+16) {
tmp = 1.0 - y;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.55e+93: tmp = y * x elif x <= 2.2e+16: tmp = 1.0 - y else: tmp = y * x return tmp
function code(x, y) tmp = 0.0 if (x <= -1.55e+93) tmp = Float64(y * x); elseif (x <= 2.2e+16) 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 <= -1.55e+93) tmp = y * x; elseif (x <= 2.2e+16) tmp = 1.0 - y; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.55e+93], N[(y * x), $MachinePrecision], If[LessEqual[x, 2.2e+16], N[(1.0 - y), $MachinePrecision], N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.55 \cdot 10^{+93}:\\
\;\;\;\;y \cdot x\\
\mathbf{elif}\;x \leq 2.2 \cdot 10^{+16}:\\
\;\;\;\;1 - y\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if x < -1.5500000000000001e93 or 2.2e16 < x Initial program 52.9%
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-*.f6486.9%
Simplified86.9%
if -1.5500000000000001e93 < x < 2.2e16Initial program 94.3%
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--.f6493.0%
Simplified93.0%
(FPCore (x y) :precision binary64 (if (<= x -6.5e+96) (* y x) (if (<= x 1.3e+20) 1.0 (* y x))))
double code(double x, double y) {
double tmp;
if (x <= -6.5e+96) {
tmp = y * x;
} else if (x <= 1.3e+20) {
tmp = 1.0;
} 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 <= (-6.5d+96)) then
tmp = y * x
else if (x <= 1.3d+20) then
tmp = 1.0d0
else
tmp = y * x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -6.5e+96) {
tmp = y * x;
} else if (x <= 1.3e+20) {
tmp = 1.0;
} else {
tmp = y * x;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -6.5e+96: tmp = y * x elif x <= 1.3e+20: tmp = 1.0 else: tmp = y * x return tmp
function code(x, y) tmp = 0.0 if (x <= -6.5e+96) tmp = Float64(y * x); elseif (x <= 1.3e+20) tmp = 1.0; else tmp = Float64(y * x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -6.5e+96) tmp = y * x; elseif (x <= 1.3e+20) tmp = 1.0; else tmp = y * x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -6.5e+96], N[(y * x), $MachinePrecision], If[LessEqual[x, 1.3e+20], 1.0, N[(y * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6.5 \cdot 10^{+96}:\\
\;\;\;\;y \cdot x\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{+20}:\\
\;\;\;\;1\\
\mathbf{else}:\\
\;\;\;\;y \cdot x\\
\end{array}
\end{array}
if x < -6.5e96 or 1.3e20 < x Initial program 52.9%
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-*.f6487.6%
Simplified87.6%
if -6.5e96 < x < 1.3e20Initial program 93.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 y around 0
Simplified49.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 78.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%
(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 78.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 y around 0
Simplified35.9%
(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 2024158
(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))))