
(FPCore (x y z) :precision binary64 (/ (+ x (* y (- z x))) z))
double code(double x, double y, double z) {
return (x + (y * (z - x))) / z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (x + (y * (z - x))) / z
end function
public static double code(double x, double y, double z) {
return (x + (y * (z - x))) / z;
}
def code(x, y, z): return (x + (y * (z - x))) / z
function code(x, y, z) return Float64(Float64(x + Float64(y * Float64(z - x))) / z) end
function tmp = code(x, y, z) tmp = (x + (y * (z - x))) / z; end
code[x_, y_, z_] := N[(N[(x + N[(y * N[(z - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + y \cdot \left(z - x\right)}{z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 8 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (/ (+ x (* y (- z x))) z))
double code(double x, double y, double z) {
return (x + (y * (z - x))) / z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (x + (y * (z - x))) / z
end function
public static double code(double x, double y, double z) {
return (x + (y * (z - x))) / z;
}
def code(x, y, z): return (x + (y * (z - x))) / z
function code(x, y, z) return Float64(Float64(x + Float64(y * Float64(z - x))) / z) end
function tmp = code(x, y, z) tmp = (x + (y * (z - x))) / z; end
code[x_, y_, z_] := N[(N[(x + N[(y * N[(z - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + y \cdot \left(z - x\right)}{z}
\end{array}
(FPCore (x y z) :precision binary64 (fma (- 1.0 y) (/ x z) y))
double code(double x, double y, double z) {
return fma((1.0 - y), (x / z), y);
}
function code(x, y, z) return fma(Float64(1.0 - y), Float64(x / z), y) end
code[x_, y_, z_] := N[(N[(1.0 - y), $MachinePrecision] * N[(x / z), $MachinePrecision] + y), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(1 - y, \frac{x}{z}, y\right)
\end{array}
Initial program 89.7%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites99.9%
(FPCore (x y z) :precision binary64 (let* ((t_0 (fma (- y) (/ x z) y))) (if (<= y -1.0) t_0 (if (<= y 0.00235) (fma 1.0 (/ x z) y) t_0))))
double code(double x, double y, double z) {
double t_0 = fma(-y, (x / z), y);
double tmp;
if (y <= -1.0) {
tmp = t_0;
} else if (y <= 0.00235) {
tmp = fma(1.0, (x / z), y);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = fma(Float64(-y), Float64(x / z), y) tmp = 0.0 if (y <= -1.0) tmp = t_0; elseif (y <= 0.00235) tmp = fma(1.0, Float64(x / z), y); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[((-y) * N[(x / z), $MachinePrecision] + y), $MachinePrecision]}, If[LessEqual[y, -1.0], t$95$0, If[LessEqual[y, 0.00235], N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-y, \frac{x}{z}, y\right)\\
\mathbf{if}\;y \leq -1:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 0.00235:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1 or 0.00235000000000000009 < y Initial program 78.5%
Taylor expanded in y around inf
associate-/l*N/A
div-subN/A
sub-negN/A
*-inversesN/A
sub-negN/A
distribute-lft-out--N/A
*-rgt-identityN/A
associate-/l*N/A
*-commutativeN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6489.1
Applied rewrites89.1%
Applied rewrites99.1%
if -1 < y < 0.00235000000000000009Initial program 99.9%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites100.0%
Taylor expanded in y around 0
Applied rewrites98.1%
(FPCore (x y z) :precision binary64 (if (<= y -1.0) (- y (/ (* x y) z)) (if (<= y 0.00235) (fma 1.0 (/ x z) y) (- y (* x (/ y z))))))
double code(double x, double y, double z) {
double tmp;
if (y <= -1.0) {
tmp = y - ((x * y) / z);
} else if (y <= 0.00235) {
tmp = fma(1.0, (x / z), y);
} else {
tmp = y - (x * (y / z));
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= -1.0) tmp = Float64(y - Float64(Float64(x * y) / z)); elseif (y <= 0.00235) tmp = fma(1.0, Float64(x / z), y); else tmp = Float64(y - Float64(x * Float64(y / z))); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, -1.0], N[(y - N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 0.00235], N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision], N[(y - N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1:\\
\;\;\;\;y - \frac{x \cdot y}{z}\\
\mathbf{elif}\;y \leq 0.00235:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\mathbf{else}:\\
\;\;\;\;y - x \cdot \frac{y}{z}\\
\end{array}
\end{array}
if y < -1Initial program 86.8%
Taylor expanded in y around inf
associate-/l*N/A
div-subN/A
sub-negN/A
*-inversesN/A
sub-negN/A
distribute-lft-out--N/A
*-rgt-identityN/A
associate-/l*N/A
*-commutativeN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6493.1
Applied rewrites93.1%
if -1 < y < 0.00235000000000000009Initial program 99.9%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites100.0%
Taylor expanded in y around 0
Applied rewrites98.1%
if 0.00235000000000000009 < y Initial program 70.9%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in y around inf
distribute-lft-out--N/A
*-commutativeN/A
div-subN/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
lower--.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6492.5
Applied rewrites92.5%
Final simplification95.6%
(FPCore (x y z) :precision binary64 (let* ((t_0 (- y (* x (/ y z))))) (if (<= y -1.0) t_0 (if (<= y 0.00235) (fma 1.0 (/ x z) y) t_0))))
double code(double x, double y, double z) {
double t_0 = y - (x * (y / z));
double tmp;
if (y <= -1.0) {
tmp = t_0;
} else if (y <= 0.00235) {
tmp = fma(1.0, (x / z), y);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(y - Float64(x * Float64(y / z))) tmp = 0.0 if (y <= -1.0) tmp = t_0; elseif (y <= 0.00235) tmp = fma(1.0, Float64(x / z), y); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(y - N[(x * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.0], t$95$0, If[LessEqual[y, 0.00235], N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y - x \cdot \frac{y}{z}\\
\mathbf{if}\;y \leq -1:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 0.00235:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1 or 0.00235000000000000009 < y Initial program 78.5%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in y around inf
distribute-lft-out--N/A
*-commutativeN/A
div-subN/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
lower--.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6489.6
Applied rewrites89.6%
if -1 < y < 0.00235000000000000009Initial program 99.9%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites100.0%
Taylor expanded in y around 0
Applied rewrites98.1%
(FPCore (x y z) :precision binary64 (if (<= x -1.36e+16) (/ x z) (if (<= x 8e-68) (/ (* y z) z) (/ x z))))
double code(double x, double y, double z) {
double tmp;
if (x <= -1.36e+16) {
tmp = x / z;
} else if (x <= 8e-68) {
tmp = (y * z) / z;
} else {
tmp = x / z;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (x <= (-1.36d+16)) then
tmp = x / z
else if (x <= 8d-68) then
tmp = (y * z) / z
else
tmp = x / z
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (x <= -1.36e+16) {
tmp = x / z;
} else if (x <= 8e-68) {
tmp = (y * z) / z;
} else {
tmp = x / z;
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -1.36e+16: tmp = x / z elif x <= 8e-68: tmp = (y * z) / z else: tmp = x / z return tmp
function code(x, y, z) tmp = 0.0 if (x <= -1.36e+16) tmp = Float64(x / z); elseif (x <= 8e-68) tmp = Float64(Float64(y * z) / z); else tmp = Float64(x / z); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (x <= -1.36e+16) tmp = x / z; elseif (x <= 8e-68) tmp = (y * z) / z; else tmp = x / z; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -1.36e+16], N[(x / z), $MachinePrecision], If[LessEqual[x, 8e-68], N[(N[(y * z), $MachinePrecision] / z), $MachinePrecision], N[(x / z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.36 \cdot 10^{+16}:\\
\;\;\;\;\frac{x}{z}\\
\mathbf{elif}\;x \leq 8 \cdot 10^{-68}:\\
\;\;\;\;\frac{y \cdot z}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{z}\\
\end{array}
\end{array}
if x < -1.36e16 or 8.00000000000000053e-68 < x Initial program 88.2%
Taylor expanded in y around 0
lower-/.f6454.8
Applied rewrites54.8%
if -1.36e16 < x < 8.00000000000000053e-68Initial program 91.7%
Taylor expanded in x around 0
lower-*.f6462.1
Applied rewrites62.1%
(FPCore (x y z) :precision binary64 (if (<= y -6.8e+235) (/ (* x y) (- z)) (fma 1.0 (/ x z) y)))
double code(double x, double y, double z) {
double tmp;
if (y <= -6.8e+235) {
tmp = (x * y) / -z;
} else {
tmp = fma(1.0, (x / z), y);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= -6.8e+235) tmp = Float64(Float64(x * y) / Float64(-z)); else tmp = fma(1.0, Float64(x / z), y); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, -6.8e+235], N[(N[(x * y), $MachinePrecision] / (-z)), $MachinePrecision], N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.8 \cdot 10^{+235}:\\
\;\;\;\;\frac{x \cdot y}{-z}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\end{array}
\end{array}
if y < -6.79999999999999991e235Initial program 93.9%
Taylor expanded in y around inf
associate-/l*N/A
div-subN/A
sub-negN/A
*-inversesN/A
sub-negN/A
distribute-lft-out--N/A
*-rgt-identityN/A
associate-/l*N/A
*-commutativeN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6493.2
Applied rewrites93.2%
Taylor expanded in x around inf
Applied rewrites79.3%
if -6.79999999999999991e235 < y Initial program 89.4%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in y around 0
Applied rewrites80.8%
Final simplification80.7%
(FPCore (x y z) :precision binary64 (fma 1.0 (/ x z) y))
double code(double x, double y, double z) {
return fma(1.0, (x / z), y);
}
function code(x, y, z) return fma(1.0, Float64(x / z), y) end
code[x_, y_, z_] := N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(1, \frac{x}{z}, y\right)
\end{array}
Initial program 89.7%
Taylor expanded in x around 0
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
associate-/l*N/A
mul-1-negN/A
associate-+r+N/A
associate-*r/N/A
*-rgt-identityN/A
associate-+r+N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in y around 0
Applied rewrites77.9%
(FPCore (x y z) :precision binary64 (/ x z))
double code(double x, double y, double z) {
return x / z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x / z
end function
public static double code(double x, double y, double z) {
return x / z;
}
def code(x, y, z): return x / z
function code(x, y, z) return Float64(x / z) end
function tmp = code(x, y, z) tmp = x / z; end
code[x_, y_, z_] := N[(x / z), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{z}
\end{array}
Initial program 89.7%
Taylor expanded in y around 0
lower-/.f6441.2
Applied rewrites41.2%
(FPCore (x y z) :precision binary64 (- (+ y (/ x z)) (/ y (/ z x))))
double code(double x, double y, double z) {
return (y + (x / z)) - (y / (z / x));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (y + (x / z)) - (y / (z / x))
end function
public static double code(double x, double y, double z) {
return (y + (x / z)) - (y / (z / x));
}
def code(x, y, z): return (y + (x / z)) - (y / (z / x))
function code(x, y, z) return Float64(Float64(y + Float64(x / z)) - Float64(y / Float64(z / x))) end
function tmp = code(x, y, z) tmp = (y + (x / z)) - (y / (z / x)); end
code[x_, y_, z_] := N[(N[(y + N[(x / z), $MachinePrecision]), $MachinePrecision] - N[(y / N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(y + \frac{x}{z}\right) - \frac{y}{\frac{z}{x}}
\end{array}
herbie shell --seed 2024220
(FPCore (x y z)
:name "Diagrams.Backend.Rasterific:rasterificRadialGradient from diagrams-rasterific-1.3.1.3"
:precision binary64
:alt
(! :herbie-platform default (- (+ y (/ x z)) (/ y (/ z x))))
(/ (+ x (* y (- z x))) z))