
(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 90.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%
(FPCore (x y z) :precision binary64 (if (<= (/ (+ x (* y (- z x))) z) (- INFINITY)) (* x (- (/ y z))) (fma 1.0 (/ x z) y)))
double code(double x, double y, double z) {
double tmp;
if (((x + (y * (z - x))) / z) <= -((double) INFINITY)) {
tmp = x * -(y / z);
} else {
tmp = fma(1.0, (x / z), y);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(Float64(x + Float64(y * Float64(z - x))) / z) <= Float64(-Inf)) tmp = Float64(x * Float64(-Float64(y / z))); else tmp = fma(1.0, Float64(x / z), y); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(N[(x + N[(y * N[(z - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], (-Infinity)], N[(x * (-N[(y / z), $MachinePrecision])), $MachinePrecision], N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x + y \cdot \left(z - x\right)}{z} \leq -\infty:\\
\;\;\;\;x \cdot \left(-\frac{y}{z}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (*.f64 y (-.f64 z x))) z) < -inf.0Initial program 70.0%
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
sub-negN/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
mul-1-negN/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
associate-*r/N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6497.5
Applied rewrites97.5%
Taylor expanded in x around inf
Applied rewrites75.7%
if -inf.0 < (/.f64 (+.f64 x (*.f64 y (-.f64 z x))) z) Initial program 94.3%
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 rewrites82.9%
Final simplification81.8%
(FPCore (x y z) :precision binary64 (let* ((t_0 (fma (- y) (/ x z) y))) (if (<= y -1.0) t_0 (if (<= y 2.8e-10) (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 <= 2.8e-10) {
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 <= 2.8e-10) 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, 2.8e-10], 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 2.8 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1 or 2.80000000000000015e-10 < y Initial program 80.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-*.f6492.5
Applied rewrites92.5%
Applied rewrites98.3%
if -1 < y < 2.80000000000000015e-10Initial 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.4%
(FPCore (x y z) :precision binary64 (if (<= y -1.0) (fma x (- (/ y z)) y) (if (<= y 2.8e-10) (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 = fma(x, -(y / z), y);
} else if (y <= 2.8e-10) {
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 = fma(x, Float64(-Float64(y / z)), y); elseif (y <= 2.8e-10) tmp = fma(1.0, Float64(x / z), y); else tmp = Float64(y - Float64(Float64(x * y) / z)); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, -1.0], N[(x * (-N[(y / z), $MachinePrecision]) + y), $MachinePrecision], If[LessEqual[y, 2.8e-10], N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision], N[(y - N[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1:\\
\;\;\;\;\mathsf{fma}\left(x, -\frac{y}{z}, y\right)\\
\mathbf{elif}\;y \leq 2.8 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\mathbf{else}:\\
\;\;\;\;y - \frac{x \cdot y}{z}\\
\end{array}
\end{array}
if y < -1Initial program 82.8%
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
sub-negN/A
associate-/l*N/A
*-inversesN/A
*-rgt-identityN/A
mul-1-negN/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
associate-*r/N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6493.3
Applied rewrites93.3%
if -1 < y < 2.80000000000000015e-10Initial 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.4%
if 2.80000000000000015e-10 < y Initial program 78.7%
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%
Final simplification95.8%
(FPCore (x y z) :precision binary64 (let* ((t_0 (- y (/ (* x y) z)))) (if (<= y -1.0) t_0 (if (<= y 2.8e-10) (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 <= 2.8e-10) {
tmp = fma(1.0, (x / z), y);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(y - Float64(Float64(x * y) / z)) tmp = 0.0 if (y <= -1.0) tmp = t_0; elseif (y <= 2.8e-10) 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[(N[(x * y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.0], t$95$0, If[LessEqual[y, 2.8e-10], N[(1.0 * N[(x / z), $MachinePrecision] + y), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y - \frac{x \cdot y}{z}\\
\mathbf{if}\;y \leq -1:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 2.8 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(1, \frac{x}{z}, y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1 or 2.80000000000000015e-10 < y Initial program 80.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-*.f6492.5
Applied rewrites92.5%
if -1 < y < 2.80000000000000015e-10Initial 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.4%
Final simplification95.5%
(FPCore (x y z) :precision binary64 (if (<= x -5e-175) (/ x z) (if (<= x 4.5e-81) (/ (* y z) z) (/ x z))))
double code(double x, double y, double z) {
double tmp;
if (x <= -5e-175) {
tmp = x / z;
} else if (x <= 4.5e-81) {
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 <= (-5d-175)) then
tmp = x / z
else if (x <= 4.5d-81) 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 <= -5e-175) {
tmp = x / z;
} else if (x <= 4.5e-81) {
tmp = (y * z) / z;
} else {
tmp = x / z;
}
return tmp;
}
def code(x, y, z): tmp = 0 if x <= -5e-175: tmp = x / z elif x <= 4.5e-81: tmp = (y * z) / z else: tmp = x / z return tmp
function code(x, y, z) tmp = 0.0 if (x <= -5e-175) tmp = Float64(x / z); elseif (x <= 4.5e-81) 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 <= -5e-175) tmp = x / z; elseif (x <= 4.5e-81) tmp = (y * z) / z; else tmp = x / z; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[x, -5e-175], N[(x / z), $MachinePrecision], If[LessEqual[x, 4.5e-81], N[(N[(y * z), $MachinePrecision] / z), $MachinePrecision], N[(x / z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5 \cdot 10^{-175}:\\
\;\;\;\;\frac{x}{z}\\
\mathbf{elif}\;x \leq 4.5 \cdot 10^{-81}:\\
\;\;\;\;\frac{y \cdot z}{z}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{z}\\
\end{array}
\end{array}
if x < -5e-175 or 4.5e-81 < x Initial program 91.2%
Taylor expanded in y around 0
lower-/.f6457.4
Applied rewrites57.4%
if -5e-175 < x < 4.5e-81Initial program 88.9%
Taylor expanded in x around 0
lower-*.f6463.5
Applied rewrites63.5%
(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 90.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 0
Applied rewrites77.3%
(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 90.5%
Taylor expanded in y around 0
lower-/.f6445.4
Applied rewrites45.4%
(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 2024233
(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))